[ { "path": "README.md", "content": "# C++20 Fundamentals LiveLessons Code Examples\nSource code examples for our **C++20 Fundamentals LiveLessons** Videos.\n\nAt the moment, these videos are available only to O'Reilly Online Learning subscribers. For all our books, LiveLessons videos and Full Throttle live webinars on O'Reilly Online Learning, visit: https://deitel.com/LearnWithDeitel\n\nThese source-code files are (C) Copyright 2021 by Deitel & Associates, Inc. and Pearson Education, Inc. All Rights Reserved.\n\nYou may use these files for your personal purposes, but please do not repost them without our express written consent.\n\nIf you have any questions, open an issue in the Issues tab or email us: deitel at deitel dot com.\n\nThe authors and publisher of this video product have used their best efforts in preparing these videos. These efforts include the development, research, and testing of the theories and programs to determine their effectiveness. The authors and publisher make no warranty of any kind, expressed or implied, with regard to these programs or to the documentation contained in these videos. The authors and publisher shall not be liable in any event for incidental or consequential damages in connection with, or arising out of, the furnishing, performance, or use of these programs.\n" }, { "path": "examples/docker/gcc13/dockerfile", "content": "FROM ubuntu:20.04\r\nRUN apt-get update -y\r\nRUN apt-get install -y build-essential wget\r\nRUN wget --quiet --content-disposition http://kayari.org/gcc-latest/gcc-latest.deb\r\nRUN dpkg -i gcc-latest*.deb\r\nRUN /opt/gcc-latest/bin/g++ --version\r\n\r\n" }, { "path": "examples/lesson01/GuessNumber.cpp", "content": "// Randomly generate numbers between 1 and 1000 for user to guess.\n#include \n#include // contains C++11 random number generation features \nusing namespace std;\n\nbool isCorrect(int, int); // function prototype\n\nint main() {\n // use the default random-number generation engine to \n // produce uniformly distributed pseudorandom int values from 1 to 1000\n default_random_engine engine{random_device{}()};\n uniform_int_distribution randomInt{1, 1000};\n\n char response = 'n'; // determines whether to continue playing\n\n // loop until user types 'n' to quit game\n do {\n // generate random number between 1 and 1000\n // 1 is shift, 1000 is scaling factor\n const int answer{randomInt(engine)};\n\n // prompt for guess\n cout << \"I have a number between 1 and 1000.\\n\"\n << \"Can you guess my number?\\n\"\n << \"Please type your first guess.\\n? \";\n int guess;\n cin >> guess;\n\n // loop until correct number\n while (!isCorrect(guess, answer)) {\n cin >> guess;\n }\n\n // prompt for another game\n cout << \"\\nExcellent! You guessed the number!\\n\"\n << \"Would you like to play again (y or n)? \";\n cin >> response;\n\n cout << endl;\n } while (response == 'y');\n\n return 0; // indicate successful termination\n} \n\n// isCorrect returns true if guess equals answer;\n// otherwise it displays a hint and returns false\nbool isCorrect(int guess, int answer) {\n // guess is correct\n if (guess == answer) {\n return true;\n }\n\n // guess is incorrect; display hint\n if (guess < answer) {\n cout << \"Too low. Try again.\\n? \";\n }\n else {\n cout << \"Too high. Try again.\\n? \";\n }\n\n return false;\n} // end function isCorrect\n\n\n\n/**************************************************************************\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\n * Pearson Education, Inc. All Rights Reserved. *\n * *\n * DISCLAIMER: The authors and publisher of this book have used their *\n * best efforts in preparing the book. These efforts include the *\n * development, research, and testing of the theories and programs *\n * to determine their effectiveness. The authors and publisher make *\n * no warranty of any kind, expressed or implied, with regard to these *\n * programs or to the documentation contained in these books. The authors *\n * and publisher shall not be liable in any event for incidental or *\n * consequential damages in connection with, or arising out of, the *\n * furnishing, performance, or use of these programs. *\n **************************************************************************/\n" }, { "path": "examples/lesson02/fig02_01.cpp", "content": "// fig02_01.cpp\r\n// Text-printing program.\r\n#include // enables program to output data to the screen\r\n\r\n// function main begins program execution\r\nint main() {\r\n std::cout << \"Welcome to C++!\\n\"; // display message\r\n \r\n return 0; // indicate that program ended successfully\r\n} // end function main\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n /*************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n **************************************************************************/\r\n" }, { "path": "examples/lesson02/fig02_02.cpp", "content": "// fig02_02.cpp\r\n// Displaying a line of text with multiple statements.\r\n#include // enables program to output data to the screen\r\n\r\n// function main begins program execution\r\nint main() {\r\n std::cout << \"Welcome \";\r\n std::cout << \"to C++!\\n\";\r\n} // end function main\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n **************************************************************************/\r\n" }, { "path": "examples/lesson02/fig02_03.cpp", "content": "// fig02_03.cpp\r\n// Displayings multiple lines of text with a single statement.\r\n#include // enables program to output data to the screen\r\n\r\n// function main begins program execution\r\nint main() {\r\n std::cout << \"Welcome\\nto\\n\\nC++!\\n\";\r\n} // end function main\r\n\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n **************************************************************************/\r\n" }, { "path": "examples/lesson02/fig02_04.cpp", "content": "// fig02_04.cpp\r\n// Addition program that displays the sum of two integers.\r\n#include // enables program to perform input and output\r\n\r\n// function main begins program execution\r\nint main() {\r\n // declaring and initializing variables\r\n int number1{0}; // first integer to add (initialized to 0) \r\n int number2{0}; // second integer to add (initialized to 0) \r\n int sum{0}; // sum of number1 and number2 (initialized to 0)\r\n\r\n std::cout << \"Enter first integer: \"; // prompt user for data\r\n std::cin >> number1; // read first integer from user into number1\r\n\r\n std::cout << \"Enter second integer: \"; // prompt user for data\r\n std::cin >> number2; // read second integer from user into number2\r\n\r\n sum = number1 + number2; // add the numbers; store result in sum\r\n\r\n std::cout << \"Sum is \" << sum << \"\\n\"; // display sum\r\n} // end function main\r\n\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n **************************************************************************/\r\n" }, { "path": "examples/lesson02/fig02_05.cpp", "content": "// fig02_05.cpp\r\n// Comparing integers using if statements, relational operators\r\n// and equality operators.\r\n#include // enables program to perform input and output\r\n\r\nusing std::cout; // program uses cout\r\nusing std::cin; // program uses cin\r\n\r\n// function main begins program execution\r\nint main() {\r\n int number1{0}; // first integer to compare (initialized to 0)\r\n int number2{0}; // second integer to compare (initialized to 0)\r\n \r\n cout << \"Enter two integers to compare: \"; // prompt user for data\r\n cin >> number1 >> number2; // read two integers from user\r\n\r\n if (number1 == number2) {\r\n cout << number1 << \" == \" << number2 << \"\\n\";\r\n }\r\n\r\n if (number1 != number2) {\r\n cout << number1 << \" != \" << number2 << \"\\n\";\r\n }\r\n\r\n if (number1 < number2) {\r\n cout << number1 << \" < \" << number2 << \"\\n\";\r\n }\r\n\r\n if (number1 > number2) {\r\n cout << number1 << \" > \" << number2 << \"\\n\";\r\n }\r\n\r\n if (number1 <= number2) {\r\n cout << number1 << \" <= \" << number2 << \"\\n\";\r\n }\r\n\r\n if (number1 >= number2) {\r\n cout << number1 << \" >= \" << number2 << \"\\n\";\r\n }\r\n} // end function main\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n **************************************************************************/\r\n" }, { "path": "examples/lesson02/fig02_06.cpp", "content": "// fig02_06.cpp\r\n// Standard library string class test program. \r\n#include \r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n string s1{\"happy\"}; \r\n string s2{\" birthday\"};\r\n string s3; // creates an empty string\r\n \r\n // display the strings and show their lengths (length is C++20)\r\n cout << \"s1: \\\"\" << s1 << \"\\\"; length: \" << s1.length()\r\n << \"\\ns2: \\\"\" << s2 << \"\\\"; length: \" << s2.length()\r\n << \"\\ns3: \\\"\" << s3 << \"\\\"; length: \" << s3.length();\r\n\r\n // compare strings with == and !=\r\n cout << \"\\n\\nThe results of comparing s2 and s1:\" << boolalpha\r\n << \"\\ns2 == s1: \" << (s2 == s1)\r\n << \"\\ns2 != s1: \" << (s2 != s1);\r\n \r\n // test string member function empty \r\n cout << \"\\n\\nTesting s3.empty():\\n\";\r\n\r\n if (s3.empty()) {\r\n cout << \"s3 is empty; assigning to s3;\\n\";\r\n s3 = s1 + s2; // assign s3 the result of concatenating s1 and s2\r\n cout << \"s3: \\\"\" << s3 << \"\\\"\";\r\n } \r\n\r\n // testing new C++20 string member functions \r\n cout << \"\\n\\ns1 starts with \\\"ha\\\": \" << s1.starts_with(\"ha\") << \"\\n\";\r\n cout << \"s2 starts with \\\"ha\\\": \" << s2.starts_with(\"ha\") << \"\\n\";\r\n cout << \"s1 ends with \\\"ay\\\": \" << s1.ends_with(\"ay\") << \"\\n\";\r\n cout << \"s2 ends with \\\"ay\\\": \" << s2.ends_with(\"ay\") << \"\\n\";\r\n} \r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n **************************************************************************/\r\n" }, { "path": "examples/lesson03/fig03_01.cpp", "content": "// fig03_01.cpp\r\n// Solving the class-average problem using counter-controlled iteration.\r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n // initialization phase\r\n int total{0}; // initialize sum of grades entered by the user\r\n int gradeCounter{1}; // initialize grade # to be entered next\r\n\r\n // processing phase uses counter-controlled iteration\r\n while (gradeCounter <= 10) { // loop 10 times\r\n cout << \"Enter grade: \"; // prompt \r\n int grade;\r\n cin >> grade; // input next grade\r\n total = total + grade; // add grade to total\r\n gradeCounter = gradeCounter + 1; // increment counter by 1\r\n } \r\n\r\n // termination phase\r\n int average{total / 10}; // int division yields int result\r\n\r\n // display total and average of grades\r\n cout << \"\\nTotal of all 10 grades is \" << total;\r\n cout << \"\\nClass average is \" << average << \"\\n\";\r\n} \r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson03/fig03_02.cpp", "content": "// fig03_02.cpp\r\n// Solving the class-average problem using sentinel-controlled iteration. \r\n#include \r\n#include // parameterized stream manipulators \r\nusing namespace std;\r\n\r\nint main() {\r\n // initialization phase\r\n double total{0.0}; // initialize sum of grades\r\n int gradeCounter{0}; // initialize # of grades entered so far\r\n \r\n // processing phase\r\n // prompt for input and read grade from user\r\n cout << \"Enter grade or -1 to quit: \"; \r\n int grade; \r\n cin >> grade; \r\n\r\n // loop until sentinel value is read from user\r\n while (grade != -1) {\r\n total = total + grade; // add grade to total\r\n gradeCounter = gradeCounter + 1; // increment counter \r\n\r\n // prompt for input and read next grade from user\r\n cout << \"Enter grade or -1 to quit: \"; \r\n cin >> grade; \r\n }\r\n\r\n // termination phase\r\n // if user entered at least one grade\r\n if (gradeCounter != 0) { // avoid division by zero\r\n // calculate average of grades\r\n double average{total / gradeCounter};\r\n\r\n // display total and average (with two digits of precision)\r\n cout << \"\\nTotal of the \" << gradeCounter \r\n << \" grades entered is \" << total;\r\n cout << setprecision(2) << fixed; \r\n cout << \"\\nClass average is \" << average << \"\\n\"; \r\n } \r\n else { // no grades were entered, so output appropriate message\r\n cout << \"No grades were entered\\n\"; \r\n }\r\n} \r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson03/fig03_03.cpp", "content": "// fig03_03.cpp\r\n// Analysis of examination results using nested control statements.\r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n // initializing variables in declarations\r\n int passes{0}; \r\n int failures{0};\r\n int studentCounter{1}; \r\n\r\n // process 10 students using counter-controlled loop\r\n while (studentCounter <= 10) {\r\n // prompt user for input and obtain value from user\r\n cout << \"Enter result (1 = pass, 2 = fail): \";\r\n int result;\r\n cin >> result;\r\n\r\n // if...else is nested in the while statement \r\n if (result == 1) { \r\n passes = passes + 1; \r\n }\r\n else { \r\n failures = failures + 1; \r\n }\r\n\r\n // increment studentCounter so loop eventually terminates\r\n studentCounter = studentCounter + 1; \r\n } \r\n\r\n // termination phase; prepare and display results\r\n cout << \"Passed: \" << passes << \"\\nFailed: \" << failures << \"\\n\";\r\n\r\n // determine whether more than 8 students passed\r\n if (passes > 8) {\r\n cout << \"Bonus to instructor!\\n\";\r\n }\r\n} \r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson03/fig03_04.cpp", "content": "// fig03_04.cpp\r\n// Prefix increment and postfix increment operators.\r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n // demonstrate postfix increment operator\r\n int c{5}; \r\n cout << \"c before postincrement: \" << c << \"\\n\"; // prints 5\r\n cout << \" postincrementing c: \" << c++ << \"\\n\"; // prints 5\r\n cout << \" c after postincrement: \" << c << \"\\n\"; // prints 6 \r\n\r\n cout << \"\\n\"; // skip a line\r\n\r\n // demonstrate prefix increment operator\r\n c = 5; \r\n cout << \" c before preincrement: \" << c << \"\\n\"; // prints 5\r\n cout << \" preincrementing c: \" << ++c << \"\\n\"; // prints 6\r\n cout << \" c after preincrement: \" << c << \"\\n\"; // prints 6 \r\n}\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson03/fig03_05.cpp", "content": "// fig03_05.cpp\r\n// Conveniently creating and manipulating super-sized integers\r\n// with objects of the Boost Multiprecision library's cpp_int class.\r\n#include \r\n#include \r\nusing namespace std;\r\nusing boost::multiprecision::cpp_int;\r\n\t\r\nint main() {\r\n // initializing cpp_ints\r\n const cpp_int value1{\"100000000000000000000000000000\"}; // 30 digits\r\n const cpp_int value2{9223372036854775807LL}; // long long max\r\n const int value3{3}; \r\n \r\n cout << \"INITIAL VALUES\"\r\n << \"\\ncpp_int value1: \" << value1\r\n << \"\\ncpp_int value2: \" << value2\r\n << \"\\n int value3: \" << value3;\r\n \r\n // arithmetic with cpp_ints\r\n cout << \"\\n\\nADD, SUBTRACT AND MULTIPLY CPP_INT OBJECTS\"\r\n << \"\\nvalue1 + value2: \" << value1 + value2\r\n << \"\\nvalue1 - value2: \" << value1 - value2\r\n << \"\\nvalue1 * value2: \" << value1 * value2;\r\n \r\n // arithmetic mixing cpp_ints and integers\r\n cout << \"\\n\\nMULTIPLY A CPP_INT OBJECT BY INT VALUES\"\r\n << \"\\nvalue1 * value3: \" << value1 * value3\r\n << \"\\n value1 * 17: \" << value1 * 17 << \"\\n\";\r\n}\r\n\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2022 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n **************************************************************************/\r\n\r\n" }, { "path": "examples/lesson04/decimalformatter.h", "content": "// decimalformatter.h\r\n// Custom std::formatter that formats a \r\n// boost::multiprecision::cpp_dec_float_50 as a std::string\r\n// with two digits to the right of the decimal point.\r\n#pragma once\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n// short name for boost::multiprecision::cpp_dec_float_50\r\nusing decimal = boost::multiprecision::cpp_dec_float_50;\r\n\r\n// Custom formatter for boost::multiprecision::cpp_dec_float_50. \r\n// Formats as a string with two digits to the right of the decimal point.\r\n// More info at: https://fmt.dev/latest/api.html#format-api\r\ntemplate<> struct std::formatter : std::formatter {\r\n template \r\n auto format(decimal d, FormatContext& ctx) const {\r\n std::ostringstream out{};\r\n out << std::fixed << std::setprecision(2) << d;\r\n return formatter::format(out.str(), ctx);\r\n }\r\n};" }, { "path": "examples/lesson04/decimalformatter_fmt.h", "content": "// decimalformatter.h\r\n// Custom fmt::formatter that formats a \r\n// boost::multiprecision::cpp_dec_float_50 as a std::string\r\n// with two digits to the right of the decimal point.\r\n#pragma once\r\n#include \r\n#include // in C++20, this will be #include \r\n#include \r\n#include \r\n#include \r\n\r\n// short name for boost::multiprecision::cpp_dec_float_50\r\nusing decimal = boost::multiprecision::cpp_dec_float_50;\r\n\r\n// Custom formatter for boost::multiprecision::cpp_dec_float_50. \r\n// Formats as a string with two digits to the right of the decimal point.\r\n// More info at: https://fmt.dev/latest/api.html#format-api\r\ntemplate<> struct fmt::formatter : fmt::formatter {\r\n template \r\n auto format(decimal d, FormatContext& ctx) const {\r\n std::ostringstream out{};\r\n out << std::fixed << std::setprecision(2) << d;\r\n return formatter::format(out.str(), ctx);\r\n }\r\n};" }, { "path": "examples/lesson04/ex04_06.cpp", "content": "// ex04_06.cpp\r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n for (int i{1}; i <= 10; i++) {\r\n for (int j{1}; j <= 5; j++) {\r\n cout << '@';\r\n }\r\n\r\n cout << '\\n';\r\n } \r\n} \r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_01.cpp", "content": "// fig04_01.cpp\r\n// Counter-controlled iteration with the while iteration statement.\r\n#include \r\nusing namespace std;\r\n\r\nint main() { \r\n int counter{1}; // declare and initialize control variable\r\n\r\n while (counter <= 10) { // loop-continuation condition\r\n cout << counter << \" \";\r\n ++counter; // increment control variable \r\n } \r\n\r\n cout << \"\\n\"; \r\n} \r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_02.cpp", "content": "// fig04_02.cpp\r\n// Counter-controlled iteration with the for iteration statement.\r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n // for statement header includes initialization, \r\n // loop-continuation condition and increment\r\n for (int counter{1}; counter <= 10; ++counter) { \r\n cout << counter << \" \";\r\n }\r\n\r\n cout << \"\\n\";\r\n}\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_03.cpp", "content": "// fig04_03.cpp\n// Summing integers with the for statement; introducing text formatting.\n#include \n#include \nusing namespace std;\n\nint main() {\n int total{0};\n\n // total even integers from 2 through 20\n for (int number{2}; number <= 20; number += 2) {\n total += number; \n }\n\n cout << format(\"Sum is {}\\n\", total);\n} \n\n\n\n\n/**************************************************************************\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\n * Pearson Education, Inc. All Rights Reserved. *\n * *\n * DISCLAIMER: The authors and publisher of this book have used their *\n * best efforts in preparing the book. These efforts include the *\n * development, research, and testing of the theories and programs *\n * to determine their effectiveness. The authors and publisher make *\n * no warranty of any kind, expressed or implied, with regard to these *\n * programs or to the documentation contained in these books. The authors *\n * and publisher shall not be liable in any event for incidental or *\n * consequential damages in connection with, or arising out of, the *\n * furnishing, performance, or use of these programs. *\n *************************************************************************/\n" }, { "path": "examples/lesson04/fig04_03fmt.cpp", "content": "// fig04_03.cpp\n// Summing integers with the for statement; introducing text formatting.\n#include // C++20: This will be #include \n#include \nusing namespace std;\n\nint main() {\n int total{0};\n\n // total even integers from 2 through 20\n for (int number{2}; number <= 20; number += 2) {\n total += number; \n }\n\n cout << fmt::format(\"Sum is {}\\n\", total);\n} \n\n\n\n\n/**************************************************************************\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\n * Pearson Education, Inc. All Rights Reserved. *\n * *\n * DISCLAIMER: The authors and publisher of this book have used their *\n * best efforts in preparing the book. These efforts include the *\n * development, research, and testing of the theories and programs *\n * to determine their effectiveness. The authors and publisher make *\n * no warranty of any kind, expressed or implied, with regard to these *\n * programs or to the documentation contained in these books. The authors *\n * and publisher shall not be liable in any event for incidental or *\n * consequential damages in connection with, or arising out of, the *\n * furnishing, performance, or use of these programs. *\n *************************************************************************/\n" }, { "path": "examples/lesson04/fig04_04.cpp", "content": "// fig04_04.cpp\r\n// Compound-interest calculations with for.\r\n#include \r\n#include \r\n#include // for pow function\r\nusing namespace std;\r\n\r\nint main() {\r\n double principal{1000.00}; // initial amount before interest\r\n double rate{0.05}; // interest rate\r\n\r\n cout << format(\"Initial principal: {:>7.2f}\\n\", principal)\r\n << format(\" Interest rate: {:>7.2f}\\n\", rate);\r\n\r\n // display headers\r\n cout << format(\"\\n{}{:>20}\\n\", \"Year\", \"Amount on deposit\");\r\n\r\n // calculate amount on deposit for each of ten years \r\n for (int year{1}; year <= 10; ++year) { \r\n // calculate amount on deposit at the end of the specified year\r\n double amount{principal * pow(1.0 + rate, year)} ; \r\n \r\n // display the year and the amount \r\n cout << format(\"{:>4d}{:>20.2f}\\n\", year, amount);\r\n } \r\n}\r\n\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_04fmt.cpp", "content": "// fig04_04.cpp\r\n// Compound-interest calculations with for.\r\n#include // C++20: This will be #include \r\n#include \r\n#include // for pow function\r\nusing namespace std;\r\n\r\nint main() {\r\n double principal{1000.00}; // initial amount before interest\r\n double rate{0.05}; // interest rate\r\n\r\n cout << fmt::format(\"Initial principal: {:>7.2f}\\n\", principal)\r\n << fmt::format(\" Interest rate: {:>7.2f}\\n\", rate);\r\n\r\n // display headers\r\n cout << fmt::format(\"\\n{}{:>20}\\n\", \"Year\", \"Amount on deposit\");\r\n\r\n // calculate amount on deposit for each of ten years \r\n for (int year{1}; year <= 10; ++year) { \r\n // calculate amount on deposit at the end of the specified year\r\n double amount{principal * pow(1.0 + rate, year)} ; \r\n \r\n // display the year and the amount \r\n cout << fmt::format(\"{:>4d}{:>20.2f}\\n\", year, amount);\r\n } \r\n}\r\n\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_05.cpp", "content": "// fig04_05.cpp\r\n// do...while iteration statement.\r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n int counter{1}; \r\n\r\n do {\r\n cout << counter << \" \";\r\n ++counter;\r\n } while (counter <= 10); // end do...while \r\n\r\n cout << \"\\n\"; \r\n} \r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_06.cpp", "content": "// fig04_06.cpp\r\n// Using a switch statement to count letter grades.\r\n#include \r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n double total{0.0}; // sum of grades \r\n int gradeCounter{0}; // number of grades entered\r\n int aCount{0}; // count of A grades \r\n int bCount{0}; // count of B grades \r\n int cCount{0}; // count of C grades \r\n int dCount{0}; // count of D grades \r\n int fCount{0}; // count of F grades \r\n\r\n cout << \"Enter the integer grades in the range 0-100.\\n\"\r\n << \"Type the end-of-file indicator to terminate input:\\n\"\r\n << \" On UNIX/Linux/macOS type d then press Enter\\n\"\r\n << \" On Windows type z then press Enter\\n\";\r\n\r\n int grade;\r\n\r\n // loop until user enters the end-of-file indicator\r\n while (cin >> grade) { \r\n total += grade; // add grade to total\r\n ++gradeCounter; // increment number of grades\r\n \r\n // increment appropriate letter-grade counter\r\n switch (grade / 10) { \r\n case 9: // grade was between 90 \r\n case 10: // and 100, inclusive \r\n ++aCount; \r\n break; // exits switch \r\n \r\n case 8: // grade was between 80 and 89 \r\n ++bCount; \r\n break; // exits switch \r\n \r\n case 7: // grade was between 70 and 79 \r\n ++cCount; \r\n break; // exits switch \r\n \r\n case 6: // grade was between 60 and 69 \r\n ++dCount; \r\n break; // exits switch \r\n \r\n default: // grade was less than 60 \r\n ++fCount; \r\n break; // optional; exits switch anyway\r\n } // end switch \r\n } // end while \r\n\r\n // display grade report\r\n cout << \"\\nGrade Report:\\n\";\r\n\r\n // if user entered at least one grade...\r\n if (gradeCounter != 0) {\r\n // calculate average of all grades entered\r\n double average{total / gradeCounter};\r\n\r\n // output summary of results\r\n cout << format(\"Total of the {} grades entered is {}\\n\", \r\n gradeCounter, total)\r\n << format(\"Class average is {:.2f}\\n\\n\", average) \r\n << \"Summary of student's grades:\\n\"\r\n << format(\"A: {}\\nB: {}\\nC: {}\\nD: {}\\nF: {}\\n\",\r\n aCount, bCount, cCount, dCount, fCount); \r\n } \r\n else { // no grades were entered, so output appropriate message\r\n cout << \"No grades were entered\\n\";\r\n }\r\n}\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_06fmt.cpp", "content": "// fig04_06.cpp\r\n// Using a switch statement to count letter grades.\r\n#include // C++20: This will be #include \r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n double total{0.0}; // sum of grades \r\n int gradeCounter{0}; // number of grades entered\r\n int aCount{0}; // count of A grades \r\n int bCount{0}; // count of B grades \r\n int cCount{0}; // count of C grades \r\n int dCount{0}; // count of D grades \r\n int fCount{0}; // count of F grades \r\n\r\n cout << \"Enter the integer grades in the range 0-100.\\n\"\r\n << \"Type the end-of-file indicator to terminate input:\\n\"\r\n << \" On UNIX/Linux/macOS type d then press Enter\\n\"\r\n << \" On Windows type z then press Enter\\n\";\r\n\r\n int grade;\r\n\r\n // loop until user enters the end-of-file indicator\r\n while (cin >> grade) { \r\n total += grade; // add grade to total\r\n ++gradeCounter; // increment number of grades\r\n \r\n // increment appropriate letter-grade counter\r\n switch (grade / 10) { \r\n case 9: // grade was between 90 \r\n case 10: // and 100, inclusive \r\n ++aCount; \r\n break; // exits switch \r\n \r\n case 8: // grade was between 80 and 89 \r\n ++bCount; \r\n break; // exits switch \r\n \r\n case 7: // grade was between 70 and 79 \r\n ++cCount; \r\n break; // exits switch \r\n \r\n case 6: // grade was between 60 and 69 \r\n ++dCount; \r\n break; // exits switch \r\n \r\n default: // grade was less than 60 \r\n ++fCount; \r\n break; // optional; exits switch anyway\r\n } // end switch \r\n } // end while \r\n\r\n // display grade report\r\n cout << \"\\nGrade Report:\\n\";\r\n\r\n // if user entered at least one grade...\r\n if (gradeCounter != 0) {\r\n // calculate average of all grades entered\r\n double average{total / gradeCounter};\r\n\r\n // output summary of results\r\n cout << fmt::format(\"Total of the {} grades entered is {}\\n\", \r\n gradeCounter, total)\r\n << fmt::format(\"Class average is {:.2f}\\n\\n\", average) \r\n << \"Summary of student's grades:\\n\"\r\n << fmt::format(\"A: {}\\nB: {}\\nC: {}\\nD: {}\\nF: {}\\n\",\r\n aCount, bCount, cCount, dCount, fCount); \r\n } \r\n else { // no grades were entered, so output appropriate message\r\n cout << \"No grades were entered\\n\";\r\n }\r\n}\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_07.cpp", "content": "// fig04_07.cpp\r\n// if statements with initializers.\r\n#include \r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n if (int value{7}; value == 7) {\r\n cout << format(\"value is {}\\n\", value);\r\n }\r\n else {\r\n cout << format(\"value is not 7; it is {}\\n\", value);\r\n }\r\n\r\n if (int value{13}; value == 9) {\r\n cout << format(\"value is {}\\n\", value);\r\n }\r\n else {\r\n cout << format(\"value is not 9; it is {}\\n\", value);\r\n }\r\n}\r\n\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n **************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_07_with_error.cpp", "content": "// fig04_07_with_error.cpp\r\n// C++17 if statements with initializers.\r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n if (int value{7}; value == 7) {\r\n cout << \"value is \" << value << endl;\r\n }\r\n else {\r\n cout << \"value is not 7; it is \" << value << endl;\r\n }\r\n\r\n if (int value{13}; value == 9) {\r\n cout << \"value is \" << value << endl;\r\n }\r\n else {\r\n cout << \"value is not 9; it is \" << value << endl;\r\n }\r\n\r\n cout << value;\r\n}\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n **************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_07fmt.cpp", "content": "// fig04_07.cpp\r\n// if statements with initializers.\r\n#include // C++20: This will be #include \r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n if (int value{7}; value == 7) {\r\n cout << fmt::format(\"value is {}\\n\", value);\r\n }\r\n else {\r\n cout << fmt::format(\"value is not 7; it is {}\\n\", value);\r\n }\r\n\r\n if (int value{13}; value == 9) {\r\n cout << fmt::format(\"value is {}\\n\", value);\r\n }\r\n else {\r\n cout << fmt::format(\"value is not 9; it is {}\\n\", value);\r\n }\r\n}\r\n\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n **************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_08.cpp", "content": "// fig04_08.cpp\r\n// break statement exiting a for statement.\r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n int count; // control variable also used after loop \r\n \r\n for (count = 1; count <= 10; ++count) { // loop 10 times\r\n if (count == 5) {\r\n break; // terminates for loop if count is 5\r\n }\r\n\r\n cout << count << \" \";\r\n }\r\n\r\n cout << \"\\nBroke out of loop at count = \" << count << \"\\n\";\r\n} \r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_09.cpp", "content": "// fig04_09.cpp\r\n// continue statement terminating an iteration of a for statement.\r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n for (int count{1}; count <= 10; ++count) { // loop 10 times\r\n if (count == 5) {\r\n continue; // skip remaining code in loop body if count is 5\r\n }\r\n\r\n cout << count << \" \";\r\n } \r\n\r\n cout << \"\\nUsed continue to skip printing 5\\n\";\r\n}\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_10.cpp", "content": "// fig04_10.cpp\r\n// Logical operators.\r\n#include \r\n#include \r\nusing namespace std;\r\n\r\nint main() {\r\n // create truth table for && (logical AND) operator\r\n cout << \"Logical AND (&&)\\n\"\r\n << format(\"false && false: {}\\n\", false && false)\r\n << format(\"false && true: {}\\n\", false && true)\r\n << format(\"true && false: {}\\n\", true && false)\r\n << format(\"true && true: {}\\n\\n\", true && true);\r\n\r\n // create truth table for || (logical OR) operator\r\n cout << \"Logical OR (||)\\n\"\r\n << format(\"false || false: {}\\n\", false || false)\r\n << format(\"false || true: {}\\n\", false || true)\r\n << format(\"true || false: {}\\n\", true || false)\r\n << format(\"true || true: {}\\n\\n\", true || true);\r\n\r\n // create truth table for ! (logical negation) operator\r\n cout << \"Logical negation (!)\\n\"\r\n << format(\"!false: {}\\n\", !false)\r\n << format(\"!true: {}\\n\", !true);\r\n} \r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_11.cpp", "content": "// fig04_11.cpp\r\n// Using the miniz-cpp header-only library to write and read a ZIP file.\r\n#include \r\n#include \r\n#include \"zip_file.hpp\"\r\nusing namespace std;\r\n\r\nint main() {\r\n cout << \"Enter a ZIP file name: \";\r\n string zipFileName;\r\n getline(cin, zipFileName); // inputs a line of text\r\n\r\n // strings literals separated only by whitespace are combined \r\n // into a single string by the compiler\r\n string content{ \r\n \"This chapter introduces all but one of the remaining control \"\r\n \"statements--the for, do...while, switch, break and continue \"\r\n \"statements. We explore the essentials of counter-controlled \"\r\n \"iteration. We use compound-interest calculations to begin \"\r\n \"investigating the issues of processing monetary amounts. First, \"\r\n \"we discuss the representational errors associated with \"\r\n \"floating-point types. We use a switch statement to count the \"\r\n \"number of A, B, C, D and F grade equivalents in a set of \"\r\n \"numeric grades. We show C++17's enhancements that allow you to \"\r\n \"initialize one or more variables of the same type in the \"\r\n \"headers of if and switch statements.\"};\r\n\r\n cout << \"\\ncontent.length(): \" << content.length();\r\n\r\n miniz_cpp::zip_file output; // create zip_file object\r\n\r\n // write content into a text file in outputZipFile\r\n output.writestr(\"intro.txt\", content); // create file in ZIP\r\n output.save(zipFileName); // save outputZipFile to zipFileName\r\n\r\n miniz_cpp::zip_file input{zipFileName}; // load zipFileName\r\n\r\n // display input's file name and directory listing\r\n cout << \"\\n\\nZIP file's name: \" << input.get_filename()\r\n << \"\\n\\nZIP file's directory listing:\\n\";\r\n input.printdir(); \r\n\r\n // display info about the compressed intro.txt file\r\n miniz_cpp::zip_info info{input.getinfo(\"intro.txt\")};\r\n\r\n cout << \"\\nFile name: \" << info.filename\r\n << \"\\nOriginal size: \" << info.file_size\r\n << \"\\nCompressed size: \" << info.compress_size;\r\n\r\n // original file contents\r\n string extractedContent{input.read(info)};\r\n\r\n cout << \"\\n\\nOriginal contents of intro.txt:\\n\" << \r\n extractedContent << endl;\r\n}\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n *************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_12/fig04_12.cpp", "content": "// fig04_12.cpp\r\n// Compound-interest example with C++20 text formatting.\r\n#include \r\n#include // for pow function\r\n#include \"fmt/format.h\" // in C++20, this will be #include \r\nusing namespace std;\r\nusing namespace fmt; // not needed in C++20\r\n\r\nint main() {\r\n double principal{1000.00}; // initial amount before interest\r\n double rate{0.05}; // interest rate\r\n\r\n cout << format(\"Initial principal: {:>7.2f}\\n\", principal)\r\n << format(\" Interest rate: {:>7.2f}\\n\", rate);\r\n\r\n // display headers\r\n cout << format(\"\\n{}{:>20}\\n\", \"Year\", \"Amount on deposit\");\r\n\r\n // calculate amount on deposit for each of ten years\r\n for (int year{1}; year <= 10; ++year) {\r\n // calculate amount on deposit at the end of the specified year\r\n double amount = principal * pow(1.0 + rate, year);\r\n\r\n // display the year and the amount\r\n cout << format(\"{:>4d}{:>20.2f}\\n\", year, amount);\r\n }\r\n}\r\n\r\n\r\n/**************************************************************************\r\n * (C) Copyright 1992-2020 by Deitel & Associates, Inc. and *\r\n * Pearson Education, Inc. All Rights Reserved. *\r\n * *\r\n * DISCLAIMER: The authors and publisher of this book have used their *\r\n * best efforts in preparing the book. These efforts include the *\r\n * development, research, and testing of the theories and programs *\r\n * to determine their effectiveness. The authors and publisher make *\r\n * no warranty of any kind, expressed or implied, with regard to these *\r\n * programs or to the documentation contained in these books. The authors *\r\n * and publisher shall not be liable in any event for incidental or *\r\n * consequential damages in connection with, or arising out of, the *\r\n * furnishing, performance, or use of these programs. *\r\n **************************************************************************/\r\n" }, { "path": "examples/lesson04/fig04_12/fmt/core.h", "content": "// Formatting library for C++ - the core API\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_CORE_H_\n#define FMT_CORE_H_\n\n#include // std::FILE\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// The fmt library version in the form major * 10000 + minor * 100 + patch.\n#define FMT_VERSION 60200\n\n#ifdef __has_feature\n# define FMT_HAS_FEATURE(x) __has_feature(x)\n#else\n# define FMT_HAS_FEATURE(x) 0\n#endif\n\n#if defined(__has_include) && !defined(__INTELLISENSE__) && \\\n !(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1600)\n# define FMT_HAS_INCLUDE(x) __has_include(x)\n#else\n# define FMT_HAS_INCLUDE(x) 0\n#endif\n\n#ifdef __has_cpp_attribute\n# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)\n#else\n# define FMT_HAS_CPP_ATTRIBUTE(x) 0\n#endif\n\n#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \\\n (__cplusplus >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))\n\n#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \\\n (__cplusplus >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))\n\n#ifdef __clang__\n# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)\n#else\n# define FMT_CLANG_VERSION 0\n#endif\n\n#if defined(__GNUC__) && !defined(__clang__)\n# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)\n#else\n# define FMT_GCC_VERSION 0\n#endif\n\n#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)\n# define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION\n#else\n# define FMT_HAS_GXX_CXX11 0\n#endif\n\n#ifdef __NVCC__\n# define FMT_NVCC __NVCC__\n#else\n# define FMT_NVCC 0\n#endif\n\n#ifdef _MSC_VER\n# define FMT_MSC_VER _MSC_VER\n#else\n# define FMT_MSC_VER 0\n#endif\n\n// Check if relaxed C++14 constexpr is supported.\n// GCC doesn't allow throw in constexpr until version 6 (bug 67371).\n#ifndef FMT_USE_CONSTEXPR\n# define FMT_USE_CONSTEXPR \\\n (FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \\\n (FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) && \\\n !FMT_NVCC\n#endif\n#if FMT_USE_CONSTEXPR\n# define FMT_CONSTEXPR constexpr\n# define FMT_CONSTEXPR_DECL constexpr\n#else\n# define FMT_CONSTEXPR inline\n# define FMT_CONSTEXPR_DECL\n#endif\n\n#ifndef FMT_OVERRIDE\n# if FMT_HAS_FEATURE(cxx_override) || \\\n (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900\n# define FMT_OVERRIDE override\n# else\n# define FMT_OVERRIDE\n# endif\n#endif\n\n// Check if exceptions are disabled.\n#ifndef FMT_EXCEPTIONS\n# if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \\\n FMT_MSC_VER && !_HAS_EXCEPTIONS\n# define FMT_EXCEPTIONS 0\n# else\n# define FMT_EXCEPTIONS 1\n# endif\n#endif\n\n// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).\n#ifndef FMT_USE_NOEXCEPT\n# define FMT_USE_NOEXCEPT 0\n#endif\n\n#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \\\n (FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900\n# define FMT_DETECTED_NOEXCEPT noexcept\n# define FMT_HAS_CXX11_NOEXCEPT 1\n#else\n# define FMT_DETECTED_NOEXCEPT throw()\n# define FMT_HAS_CXX11_NOEXCEPT 0\n#endif\n\n#ifndef FMT_NOEXCEPT\n# if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT\n# define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT\n# else\n# define FMT_NOEXCEPT\n# endif\n#endif\n\n// [[noreturn]] is disabled on MSVC and NVCC because of bogus unreachable code\n// warnings.\n#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VER && \\\n !FMT_NVCC\n# define FMT_NORETURN [[noreturn]]\n#else\n# define FMT_NORETURN\n#endif\n\n#ifndef FMT_MAYBE_UNUSED\n# if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused)\n# define FMT_MAYBE_UNUSED [[maybe_unused]]\n# else\n# define FMT_MAYBE_UNUSED\n# endif\n#endif\n\n#ifndef FMT_DEPRECATED\n# if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VER >= 1900\n# define FMT_DEPRECATED [[deprecated]]\n# else\n# if defined(__GNUC__) || defined(__clang__)\n# define FMT_DEPRECATED __attribute__((deprecated))\n# elif FMT_MSC_VER\n# define FMT_DEPRECATED __declspec(deprecated)\n# else\n# define FMT_DEPRECATED /* deprecated */\n# endif\n# endif\n#endif\n\n// Workaround broken [[deprecated]] in the Intel, PGI and NVCC compilers.\n#if defined(__INTEL_COMPILER) || defined(__PGI) || FMT_NVCC\n# define FMT_DEPRECATED_ALIAS\n#else\n# define FMT_DEPRECATED_ALIAS FMT_DEPRECATED\n#endif\n\n#ifndef FMT_BEGIN_NAMESPACE\n# if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \\\n FMT_MSC_VER >= 1900\n# define FMT_INLINE_NAMESPACE inline namespace\n# define FMT_END_NAMESPACE \\\n } \\\n }\n# else\n# define FMT_INLINE_NAMESPACE namespace\n# define FMT_END_NAMESPACE \\\n } \\\n using namespace v6; \\\n }\n# endif\n# define FMT_BEGIN_NAMESPACE \\\n namespace fmt { \\\n FMT_INLINE_NAMESPACE v6 {\n#endif\n\n#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)\n# if FMT_MSC_VER\n# define FMT_NO_W4275 __pragma(warning(suppress : 4275))\n# else\n# define FMT_NO_W4275\n# endif\n# define FMT_CLASS_API FMT_NO_W4275\n# ifdef FMT_EXPORT\n# define FMT_API __declspec(dllexport)\n# elif defined(FMT_SHARED)\n# define FMT_API __declspec(dllimport)\n# define FMT_EXTERN_TEMPLATE_API FMT_API\n# endif\n#endif\n#ifndef FMT_CLASS_API\n# define FMT_CLASS_API\n#endif\n#ifndef FMT_API\n# if FMT_GCC_VERSION || FMT_CLANG_VERSION\n# define FMT_API __attribute__((visibility(\"default\")))\n# define FMT_EXTERN_TEMPLATE_API FMT_API\n# define FMT_INSTANTIATION_DEF_API\n# else\n# define FMT_API\n# endif\n#endif\n#ifndef FMT_EXTERN_TEMPLATE_API\n# define FMT_EXTERN_TEMPLATE_API\n#endif\n#ifndef FMT_INSTANTIATION_DEF_API\n# define FMT_INSTANTIATION_DEF_API FMT_API\n#endif\n\n#ifndef FMT_HEADER_ONLY\n# define FMT_EXTERN extern\n#else\n# define FMT_EXTERN\n#endif\n\n// libc++ supports string_view in pre-c++17.\n#if (FMT_HAS_INCLUDE() && \\\n (__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \\\n (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)\n# include \n# define FMT_USE_STRING_VIEW\n#elif FMT_HAS_INCLUDE(\"experimental/string_view\") && __cplusplus >= 201402L\n# include \n# define FMT_USE_EXPERIMENTAL_STRING_VIEW\n#endif\n\n#ifndef FMT_UNICODE\n# define FMT_UNICODE !FMT_MSC_VER\n#endif\n#if FMT_UNICODE && FMT_MSC_VER\n# pragma execution_character_set(\"utf-8\")\n#endif\n\nFMT_BEGIN_NAMESPACE\n\n// Implementations of enable_if_t and other metafunctions for older systems.\ntemplate \nusing enable_if_t = typename std::enable_if::type;\ntemplate \nusing conditional_t = typename std::conditional::type;\ntemplate using bool_constant = std::integral_constant;\ntemplate \nusing remove_reference_t = typename std::remove_reference::type;\ntemplate \nusing remove_const_t = typename std::remove_const::type;\ntemplate \nusing remove_cvref_t = typename std::remove_cv>::type;\ntemplate struct type_identity { using type = T; };\ntemplate using type_identity_t = typename type_identity::type;\n\nstruct monostate {};\n\n// An enable_if helper to be used in template parameters which results in much\n// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed\n// to workaround a bug in MSVC 2019 (see #1140 and #1186).\n#define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0\n\nnamespace internal {\n\n// A helper function to suppress bogus \"conditional expression is constant\"\n// warnings.\ntemplate FMT_CONSTEXPR T const_check(T value) { return value; }\n\n// A workaround for gcc 4.8 to make void_t work in a SFINAE context.\ntemplate struct void_t_impl { using type = void; };\n\nFMT_NORETURN FMT_API void assert_fail(const char* file, int line,\n const char* message);\n\n#ifndef FMT_ASSERT\n# ifdef NDEBUG\n// FMT_ASSERT is not empty to avoid -Werror=empty-body.\n# define FMT_ASSERT(condition, message) ((void)0)\n# else\n# define FMT_ASSERT(condition, message) \\\n ((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \\\n ? (void)0 \\\n : ::fmt::internal::assert_fail(__FILE__, __LINE__, (message)))\n# endif\n#endif\n\n#if defined(FMT_USE_STRING_VIEW)\ntemplate using std_string_view = std::basic_string_view;\n#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)\ntemplate \nusing std_string_view = std::experimental::basic_string_view;\n#else\ntemplate struct std_string_view {};\n#endif\n\n#ifdef FMT_USE_INT128\n// Do nothing.\n#elif defined(__SIZEOF_INT128__) && !FMT_NVCC\n# define FMT_USE_INT128 1\nusing int128_t = __int128_t;\nusing uint128_t = __uint128_t;\n#else\n# define FMT_USE_INT128 0\n#endif\n#if !FMT_USE_INT128\nstruct int128_t {};\nstruct uint128_t {};\n#endif\n\n// Casts a nonnegative integer to unsigned.\ntemplate \nFMT_CONSTEXPR typename std::make_unsigned::type to_unsigned(Int value) {\n FMT_ASSERT(value >= 0, \"negative value\");\n return static_cast::type>(value);\n}\n\nconstexpr unsigned char micro[] = \"\\u00B5\";\n\ntemplate constexpr bool is_unicode() {\n return FMT_UNICODE || sizeof(Char) != 1 ||\n (sizeof(micro) == 3 && micro[0] == 0xC2 && micro[1] == 0xB5);\n}\n\n#ifdef __cpp_char8_t\nusing char8_type = char8_t;\n#else\nenum char8_type : unsigned char {};\n#endif\n} // namespace internal\n\ntemplate \nusing void_t = typename internal::void_t_impl::type;\n\n/**\n An implementation of ``std::basic_string_view`` for pre-C++17. It provides a\n subset of the API. ``fmt::basic_string_view`` is used for format strings even\n if ``std::string_view`` is available to prevent issues when a library is\n compiled with a different ``-std`` option than the client code (which is not\n recommended).\n */\ntemplate class basic_string_view {\n private:\n const Char* data_;\n size_t size_;\n\n public:\n using char_type FMT_DEPRECATED_ALIAS = Char;\n using value_type = Char;\n using iterator = const Char*;\n\n FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {}\n\n /** Constructs a string reference object from a C string and a size. */\n FMT_CONSTEXPR basic_string_view(const Char* s, size_t count) FMT_NOEXCEPT\n : data_(s),\n size_(count) {}\n\n /**\n \\rst\n Constructs a string reference object from a C string computing\n the size with ``std::char_traits::length``.\n \\endrst\n */\n#if __cplusplus >= 201703L // C++17's char_traits::length() is constexpr.\n FMT_CONSTEXPR\n#endif\n basic_string_view(const Char* s)\n : data_(s), size_(std::char_traits::length(s)) {}\n\n /** Constructs a string reference from a ``std::basic_string`` object. */\n template \n FMT_CONSTEXPR basic_string_view(\n const std::basic_string& s) FMT_NOEXCEPT\n : data_(s.data()),\n size_(s.size()) {}\n\n template <\n typename S,\n FMT_ENABLE_IF(std::is_same>::value)>\n FMT_CONSTEXPR basic_string_view(S s) FMT_NOEXCEPT : data_(s.data()),\n size_(s.size()) {}\n\n /** Returns a pointer to the string data. */\n FMT_CONSTEXPR const Char* data() const { return data_; }\n\n /** Returns the string size. */\n FMT_CONSTEXPR size_t size() const { return size_; }\n\n FMT_CONSTEXPR iterator begin() const { return data_; }\n FMT_CONSTEXPR iterator end() const { return data_ + size_; }\n\n FMT_CONSTEXPR const Char& operator[](size_t pos) const { return data_[pos]; }\n\n FMT_CONSTEXPR void remove_prefix(size_t n) {\n data_ += n;\n size_ -= n;\n }\n\n // Lexicographically compare this string reference to other.\n int compare(basic_string_view other) const {\n size_t str_size = size_ < other.size_ ? size_ : other.size_;\n int result = std::char_traits::compare(data_, other.data_, str_size);\n if (result == 0)\n result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);\n return result;\n }\n\n friend bool operator==(basic_string_view lhs, basic_string_view rhs) {\n return lhs.compare(rhs) == 0;\n }\n friend bool operator!=(basic_string_view lhs, basic_string_view rhs) {\n return lhs.compare(rhs) != 0;\n }\n friend bool operator<(basic_string_view lhs, basic_string_view rhs) {\n return lhs.compare(rhs) < 0;\n }\n friend bool operator<=(basic_string_view lhs, basic_string_view rhs) {\n return lhs.compare(rhs) <= 0;\n }\n friend bool operator>(basic_string_view lhs, basic_string_view rhs) {\n return lhs.compare(rhs) > 0;\n }\n friend bool operator>=(basic_string_view lhs, basic_string_view rhs) {\n return lhs.compare(rhs) >= 0;\n }\n};\n\nusing string_view = basic_string_view;\nusing wstring_view = basic_string_view;\n\n#ifndef __cpp_char8_t\n// char8_t is deprecated; use char instead.\nusing char8_t FMT_DEPRECATED_ALIAS = internal::char8_type;\n#endif\n\n/** Specifies if ``T`` is a character type. Can be specialized by users. */\ntemplate struct is_char : std::false_type {};\ntemplate <> struct is_char : std::true_type {};\ntemplate <> struct is_char : std::true_type {};\ntemplate <> struct is_char : std::true_type {};\ntemplate <> struct is_char : std::true_type {};\ntemplate <> struct is_char : std::true_type {};\n\n/**\n \\rst\n Returns a string view of `s`. In order to add custom string type support to\n {fmt} provide an overload of `to_string_view` for it in the same namespace as\n the type for the argument-dependent lookup to work.\n\n **Example**::\n\n namespace my_ns {\n inline string_view to_string_view(const my_string& s) {\n return {s.data(), s.length()};\n }\n }\n std::string message = fmt::format(my_string(\"The answer is {}\"), 42);\n \\endrst\n */\ntemplate ::value)>\ninline basic_string_view to_string_view(const Char* s) {\n return s;\n}\n\ntemplate \ninline basic_string_view to_string_view(\n const std::basic_string& s) {\n return s;\n}\n\ntemplate \ninline basic_string_view to_string_view(basic_string_view s) {\n return s;\n}\n\ntemplate >::value)>\ninline basic_string_view to_string_view(\n internal::std_string_view s) {\n return s;\n}\n\n// A base class for compile-time strings. It is defined in the fmt namespace to\n// make formatting functions visible via ADL, e.g. format(fmt(\"{}\"), 42).\nstruct compile_string {};\n\ntemplate \nstruct is_compile_string : std::is_base_of {};\n\ntemplate ::value)>\nconstexpr basic_string_view to_string_view(const S& s) {\n return s;\n}\n\nnamespace internal {\nvoid to_string_view(...);\nusing fmt::v6::to_string_view;\n\n// Specifies whether S is a string type convertible to fmt::basic_string_view.\n// It should be a constexpr function but MSVC 2017 fails to compile it in\n// enable_if and MSVC 2015 fails to compile it as an alias template.\ntemplate \nstruct is_string : std::is_class()))> {\n};\n\ntemplate struct char_t_impl {};\ntemplate struct char_t_impl::value>> {\n using result = decltype(to_string_view(std::declval()));\n using type = typename result::value_type;\n};\n\nstruct error_handler {\n FMT_CONSTEXPR error_handler() = default;\n FMT_CONSTEXPR error_handler(const error_handler&) = default;\n\n // This function is intentionally not constexpr to give a compile-time error.\n FMT_NORETURN FMT_API void on_error(const char* message);\n};\n} // namespace internal\n\n/** String's character type. */\ntemplate using char_t = typename internal::char_t_impl::type;\n\n/**\n \\rst\n Parsing context consisting of a format string range being parsed and an\n argument counter for automatic indexing.\n\n You can use one of the following type aliases for common character types:\n\n +-----------------------+-------------------------------------+\n | Type | Definition |\n +=======================+=====================================+\n | format_parse_context | basic_format_parse_context |\n +-----------------------+-------------------------------------+\n | wformat_parse_context | basic_format_parse_context |\n +-----------------------+-------------------------------------+\n \\endrst\n */\ntemplate \nclass basic_format_parse_context : private ErrorHandler {\n private:\n basic_string_view format_str_;\n int next_arg_id_;\n\n public:\n using char_type = Char;\n using iterator = typename basic_string_view::iterator;\n\n explicit FMT_CONSTEXPR basic_format_parse_context(\n basic_string_view format_str, ErrorHandler eh = ErrorHandler())\n : ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}\n\n /**\n Returns an iterator to the beginning of the format string range being\n parsed.\n */\n FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT {\n return format_str_.begin();\n }\n\n /**\n Returns an iterator past the end of the format string range being parsed.\n */\n FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT { return format_str_.end(); }\n\n /** Advances the begin iterator to ``it``. */\n FMT_CONSTEXPR void advance_to(iterator it) {\n format_str_.remove_prefix(internal::to_unsigned(it - begin()));\n }\n\n /**\n Reports an error if using the manual argument indexing; otherwise returns\n the next argument index and switches to the automatic indexing.\n */\n FMT_CONSTEXPR int next_arg_id() {\n if (next_arg_id_ >= 0) return next_arg_id_++;\n on_error(\"cannot switch from manual to automatic argument indexing\");\n return 0;\n }\n\n /**\n Reports an error if using the automatic argument indexing; otherwise\n switches to the manual indexing.\n */\n FMT_CONSTEXPR void check_arg_id(int) {\n if (next_arg_id_ > 0)\n on_error(\"cannot switch from automatic to manual argument indexing\");\n else\n next_arg_id_ = -1;\n }\n\n FMT_CONSTEXPR void check_arg_id(basic_string_view) {}\n\n FMT_CONSTEXPR void on_error(const char* message) {\n ErrorHandler::on_error(message);\n }\n\n FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; }\n};\n\nusing format_parse_context = basic_format_parse_context;\nusing wformat_parse_context = basic_format_parse_context;\n\ntemplate \nusing basic_parse_context FMT_DEPRECATED_ALIAS =\n basic_format_parse_context;\nusing parse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context;\nusing wparse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context;\n\ntemplate class basic_format_arg;\ntemplate class basic_format_args;\n\n// A formatter for objects of type T.\ntemplate \nstruct formatter {\n // A deleted default constructor indicates a disabled formatter.\n formatter() = delete;\n};\n\ntemplate \nstruct FMT_DEPRECATED convert_to_int\n : bool_constant::value &&\n std::is_convertible::value> {};\n\n// Specifies if T has an enabled formatter specialization. A type can be\n// formattable even if it doesn't have a formatter e.g. via a conversion.\ntemplate \nusing has_formatter =\n std::is_constructible>;\n\nnamespace internal {\n\n/** A contiguous memory buffer with an optional growing ability. */\ntemplate class buffer {\n private:\n T* ptr_;\n std::size_t size_;\n std::size_t capacity_;\n\n protected:\n // Don't initialize ptr_ since it is not accessed to save a few cycles.\n buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}\n\n buffer(T* p = nullptr, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT\n : ptr_(p),\n size_(sz),\n capacity_(cap) {}\n\n /** Sets the buffer data and capacity. */\n void set(T* buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {\n ptr_ = buf_data;\n capacity_ = buf_capacity;\n }\n\n /** Increases the buffer capacity to hold at least *capacity* elements. */\n virtual void grow(std::size_t capacity) = 0;\n\n public:\n using value_type = T;\n using const_reference = const T&;\n\n buffer(const buffer&) = delete;\n void operator=(const buffer&) = delete;\n virtual ~buffer() = default;\n\n T* begin() FMT_NOEXCEPT { return ptr_; }\n T* end() FMT_NOEXCEPT { return ptr_ + size_; }\n\n const T* begin() const FMT_NOEXCEPT { return ptr_; }\n const T* end() const FMT_NOEXCEPT { return ptr_ + size_; }\n\n /** Returns the size of this buffer. */\n std::size_t size() const FMT_NOEXCEPT { return size_; }\n\n /** Returns the capacity of this buffer. */\n std::size_t capacity() const FMT_NOEXCEPT { return capacity_; }\n\n /** Returns a pointer to the buffer data. */\n T* data() FMT_NOEXCEPT { return ptr_; }\n\n /** Returns a pointer to the buffer data. */\n const T* data() const FMT_NOEXCEPT { return ptr_; }\n\n /**\n Resizes the buffer. If T is a POD type new elements may not be initialized.\n */\n void resize(std::size_t new_size) {\n reserve(new_size);\n size_ = new_size;\n }\n\n /** Clears this buffer. */\n void clear() { size_ = 0; }\n\n /** Reserves space to store at least *capacity* elements. */\n void reserve(std::size_t new_capacity) {\n if (new_capacity > capacity_) grow(new_capacity);\n }\n\n void push_back(const T& value) {\n reserve(size_ + 1);\n ptr_[size_++] = value;\n }\n\n /** Appends data to the end of the buffer. */\n template void append(const U* begin, const U* end);\n\n template T& operator[](I index) { return ptr_[index]; }\n template const T& operator[](I index) const {\n return ptr_[index];\n }\n};\n\n// A container-backed buffer.\ntemplate \nclass container_buffer : public buffer {\n private:\n Container& container_;\n\n protected:\n void grow(std::size_t capacity) FMT_OVERRIDE {\n container_.resize(capacity);\n this->set(&container_[0], capacity);\n }\n\n public:\n explicit container_buffer(Container& c)\n : buffer(c.size()), container_(c) {}\n};\n\n// Extracts a reference to the container from back_insert_iterator.\ntemplate \ninline Container& get_container(std::back_insert_iterator it) {\n using bi_iterator = std::back_insert_iterator;\n struct accessor : bi_iterator {\n accessor(bi_iterator iter) : bi_iterator(iter) {}\n using bi_iterator::container;\n };\n return *accessor(it).container;\n}\n\ntemplate \nstruct fallback_formatter {\n fallback_formatter() = delete;\n};\n\n// Specifies if T has an enabled fallback_formatter specialization.\ntemplate \nusing has_fallback_formatter =\n std::is_constructible>;\n\ntemplate struct named_arg_base;\ntemplate struct named_arg;\n\nenum class type {\n none_type,\n named_arg_type,\n // Integer types should go first,\n int_type,\n uint_type,\n long_long_type,\n ulong_long_type,\n int128_type,\n uint128_type,\n bool_type,\n char_type,\n last_integer_type = char_type,\n // followed by floating-point types.\n float_type,\n double_type,\n long_double_type,\n last_numeric_type = long_double_type,\n cstring_type,\n string_type,\n pointer_type,\n custom_type\n};\n\n// Maps core type T to the corresponding type enum constant.\ntemplate \nstruct type_constant : std::integral_constant {};\n\n#define FMT_TYPE_CONSTANT(Type, constant) \\\n template \\\n struct type_constant \\\n : std::integral_constant {}\n\nFMT_TYPE_CONSTANT(const named_arg_base&, named_arg_type);\nFMT_TYPE_CONSTANT(int, int_type);\nFMT_TYPE_CONSTANT(unsigned, uint_type);\nFMT_TYPE_CONSTANT(long long, long_long_type);\nFMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);\nFMT_TYPE_CONSTANT(int128_t, int128_type);\nFMT_TYPE_CONSTANT(uint128_t, uint128_type);\nFMT_TYPE_CONSTANT(bool, bool_type);\nFMT_TYPE_CONSTANT(Char, char_type);\nFMT_TYPE_CONSTANT(float, float_type);\nFMT_TYPE_CONSTANT(double, double_type);\nFMT_TYPE_CONSTANT(long double, long_double_type);\nFMT_TYPE_CONSTANT(const Char*, cstring_type);\nFMT_TYPE_CONSTANT(basic_string_view, string_type);\nFMT_TYPE_CONSTANT(const void*, pointer_type);\n\nFMT_CONSTEXPR bool is_integral_type(type t) {\n FMT_ASSERT(t != type::named_arg_type, \"invalid argument type\");\n return t > type::none_type && t <= type::last_integer_type;\n}\n\nFMT_CONSTEXPR bool is_arithmetic_type(type t) {\n FMT_ASSERT(t != type::named_arg_type, \"invalid argument type\");\n return t > type::none_type && t <= type::last_numeric_type;\n}\n\ntemplate struct string_value {\n const Char* data;\n std::size_t size;\n};\n\ntemplate struct custom_value {\n using parse_context = basic_format_parse_context;\n const void* value;\n void (*format)(const void* arg, parse_context& parse_ctx, Context& ctx);\n};\n\n// A formatting argument value.\ntemplate class value {\n public:\n using char_type = typename Context::char_type;\n\n union {\n int int_value;\n unsigned uint_value;\n long long long_long_value;\n unsigned long long ulong_long_value;\n int128_t int128_value;\n uint128_t uint128_value;\n bool bool_value;\n char_type char_value;\n float float_value;\n double double_value;\n long double long_double_value;\n const void* pointer;\n string_value string;\n custom_value custom;\n const named_arg_base* named_arg;\n };\n\n FMT_CONSTEXPR value(int val = 0) : int_value(val) {}\n FMT_CONSTEXPR value(unsigned val) : uint_value(val) {}\n value(long long val) : long_long_value(val) {}\n value(unsigned long long val) : ulong_long_value(val) {}\n value(int128_t val) : int128_value(val) {}\n value(uint128_t val) : uint128_value(val) {}\n value(float val) : float_value(val) {}\n value(double val) : double_value(val) {}\n value(long double val) : long_double_value(val) {}\n value(bool val) : bool_value(val) {}\n value(char_type val) : char_value(val) {}\n value(const char_type* val) { string.data = val; }\n value(basic_string_view val) {\n string.data = val.data();\n string.size = val.size();\n }\n value(const void* val) : pointer(val) {}\n\n template value(const T& val) {\n custom.value = &val;\n // Get the formatter type through the context to allow different contexts\n // have different extension points, e.g. `formatter` for `format` and\n // `printf_formatter` for `printf`.\n custom.format = format_custom_arg<\n T, conditional_t::value,\n typename Context::template formatter_type,\n fallback_formatter>>;\n }\n\n value(const named_arg_base& val) { named_arg = &val; }\n\n private:\n // Formats an argument of a custom type, such as a user-defined class.\n template \n static void format_custom_arg(\n const void* arg, basic_format_parse_context& parse_ctx,\n Context& ctx) {\n Formatter f;\n parse_ctx.advance_to(f.parse(parse_ctx));\n ctx.advance_to(f.format(*static_cast(arg), ctx));\n }\n};\n\ntemplate \nFMT_CONSTEXPR basic_format_arg make_arg(const T& value);\n\n// To minimize the number of types we need to deal with, long is translated\n// either to int or to long long depending on its size.\nenum { long_short = sizeof(long) == sizeof(int) };\nusing long_type = conditional_t;\nusing ulong_type = conditional_t;\n\n// Maps formatting arguments to core types.\ntemplate struct arg_mapper {\n using char_type = typename Context::char_type;\n\n FMT_CONSTEXPR int map(signed char val) { return val; }\n FMT_CONSTEXPR unsigned map(unsigned char val) { return val; }\n FMT_CONSTEXPR int map(short val) { return val; }\n FMT_CONSTEXPR unsigned map(unsigned short val) { return val; }\n FMT_CONSTEXPR int map(int val) { return val; }\n FMT_CONSTEXPR unsigned map(unsigned val) { return val; }\n FMT_CONSTEXPR long_type map(long val) { return val; }\n FMT_CONSTEXPR ulong_type map(unsigned long val) { return val; }\n FMT_CONSTEXPR long long map(long long val) { return val; }\n FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; }\n FMT_CONSTEXPR int128_t map(int128_t val) { return val; }\n FMT_CONSTEXPR uint128_t map(uint128_t val) { return val; }\n FMT_CONSTEXPR bool map(bool val) { return val; }\n\n template ::value)>\n FMT_CONSTEXPR char_type map(T val) {\n static_assert(\n std::is_same::value || std::is_same::value,\n \"mixing character types is disallowed\");\n return val;\n }\n\n FMT_CONSTEXPR float map(float val) { return val; }\n FMT_CONSTEXPR double map(double val) { return val; }\n FMT_CONSTEXPR long double map(long double val) { return val; }\n\n FMT_CONSTEXPR const char_type* map(char_type* val) { return val; }\n FMT_CONSTEXPR const char_type* map(const char_type* val) { return val; }\n template ::value)>\n FMT_CONSTEXPR basic_string_view map(const T& val) {\n static_assert(std::is_same>::value,\n \"mixing character types is disallowed\");\n return to_string_view(val);\n }\n template , T>::value &&\n !is_string::value && !has_formatter::value &&\n !has_fallback_formatter::value)>\n FMT_CONSTEXPR basic_string_view map(const T& val) {\n return basic_string_view(val);\n }\n template <\n typename T,\n FMT_ENABLE_IF(\n std::is_constructible, T>::value &&\n !std::is_constructible, T>::value &&\n !is_string::value && !has_formatter::value &&\n !has_fallback_formatter::value)>\n FMT_CONSTEXPR basic_string_view map(const T& val) {\n return std_string_view(val);\n }\n FMT_CONSTEXPR const char* map(const signed char* val) {\n static_assert(std::is_same::value, \"invalid string type\");\n return reinterpret_cast(val);\n }\n FMT_CONSTEXPR const char* map(const unsigned char* val) {\n static_assert(std::is_same::value, \"invalid string type\");\n return reinterpret_cast(val);\n }\n\n FMT_CONSTEXPR const void* map(void* val) { return val; }\n FMT_CONSTEXPR const void* map(const void* val) { return val; }\n FMT_CONSTEXPR const void* map(std::nullptr_t val) { return val; }\n template FMT_CONSTEXPR int map(const T*) {\n // Formatting of arbitrary pointers is disallowed. If you want to output\n // a pointer cast it to \"void *\" or \"const void *\". In particular, this\n // forbids formatting of \"[const] volatile char *\" which is printed as bool\n // by iostreams.\n static_assert(!sizeof(T), \"formatting of non-void pointers is disallowed\");\n return 0;\n }\n\n template ::value &&\n !has_formatter::value &&\n !has_fallback_formatter::value)>\n FMT_CONSTEXPR auto map(const T& val)\n -> decltype(std::declval().map(\n static_cast::type>(val))) {\n return map(static_cast::type>(val));\n }\n template ::value && !is_char::value &&\n (has_formatter::value ||\n has_fallback_formatter::value))>\n FMT_CONSTEXPR const T& map(const T& val) {\n return val;\n }\n\n template \n FMT_CONSTEXPR const named_arg_base& map(\n const named_arg& val) {\n auto arg = make_arg(val.value);\n std::memcpy(val.data, &arg, sizeof(arg));\n return val;\n }\n\n int map(...) {\n constexpr bool formattable = sizeof(Context) == 0;\n static_assert(\n formattable,\n \"Cannot format argument. To make type T formattable provide a \"\n \"formatter specialization: \"\n \"https://fmt.dev/latest/api.html#formatting-user-defined-types\");\n return 0;\n }\n};\n\n// A type constant after applying arg_mapper.\ntemplate \nusing mapped_type_constant =\n type_constant().map(std::declval())),\n typename Context::char_type>;\n\nenum { packed_arg_bits = 5 };\n// Maximum number of arguments with packed types.\nenum { max_packed_args = 63 / packed_arg_bits };\nenum : unsigned long long { is_unpacked_bit = 1ULL << 63 };\n\ntemplate class arg_map;\n} // namespace internal\n\n// A formatting argument. It is a trivially copyable/constructible type to\n// allow storage in basic_memory_buffer.\ntemplate class basic_format_arg {\n private:\n internal::value value_;\n internal::type type_;\n\n template \n friend FMT_CONSTEXPR basic_format_arg internal::make_arg(\n const T& value);\n\n template \n friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,\n const basic_format_arg& arg)\n -> decltype(vis(0));\n\n friend class basic_format_args;\n friend class internal::arg_map;\n\n using char_type = typename Context::char_type;\n\n public:\n class handle {\n public:\n explicit handle(internal::custom_value custom) : custom_(custom) {}\n\n void format(basic_format_parse_context& parse_ctx,\n Context& ctx) const {\n custom_.format(custom_.value, parse_ctx, ctx);\n }\n\n private:\n internal::custom_value custom_;\n };\n\n FMT_CONSTEXPR basic_format_arg() : type_(internal::type::none_type) {}\n\n FMT_CONSTEXPR explicit operator bool() const FMT_NOEXCEPT {\n return type_ != internal::type::none_type;\n }\n\n internal::type type() const { return type_; }\n\n bool is_integral() const { return internal::is_integral_type(type_); }\n bool is_arithmetic() const { return internal::is_arithmetic_type(type_); }\n};\n\n/**\n \\rst\n Visits an argument dispatching to the appropriate visit method based on\n the argument type. For example, if the argument type is ``double`` then\n ``vis(value)`` will be called with the value of type ``double``.\n \\endrst\n */\ntemplate \nFMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,\n const basic_format_arg& arg)\n -> decltype(vis(0)) {\n using char_type = typename Context::char_type;\n switch (arg.type_) {\n case internal::type::none_type:\n break;\n case internal::type::named_arg_type:\n FMT_ASSERT(false, \"invalid argument type\");\n break;\n case internal::type::int_type:\n return vis(arg.value_.int_value);\n case internal::type::uint_type:\n return vis(arg.value_.uint_value);\n case internal::type::long_long_type:\n return vis(arg.value_.long_long_value);\n case internal::type::ulong_long_type:\n return vis(arg.value_.ulong_long_value);\n#if FMT_USE_INT128\n case internal::type::int128_type:\n return vis(arg.value_.int128_value);\n case internal::type::uint128_type:\n return vis(arg.value_.uint128_value);\n#else\n case internal::type::int128_type:\n case internal::type::uint128_type:\n break;\n#endif\n case internal::type::bool_type:\n return vis(arg.value_.bool_value);\n case internal::type::char_type:\n return vis(arg.value_.char_value);\n case internal::type::float_type:\n return vis(arg.value_.float_value);\n case internal::type::double_type:\n return vis(arg.value_.double_value);\n case internal::type::long_double_type:\n return vis(arg.value_.long_double_value);\n case internal::type::cstring_type:\n return vis(arg.value_.string.data);\n case internal::type::string_type:\n return vis(basic_string_view(arg.value_.string.data,\n arg.value_.string.size));\n case internal::type::pointer_type:\n return vis(arg.value_.pointer);\n case internal::type::custom_type:\n return vis(typename basic_format_arg::handle(arg.value_.custom));\n }\n return vis(monostate());\n}\n\nnamespace internal {\n// A map from argument names to their values for named arguments.\ntemplate class arg_map {\n private:\n using char_type = typename Context::char_type;\n\n struct entry {\n basic_string_view name;\n basic_format_arg arg;\n };\n\n entry* map_;\n unsigned size_;\n\n void push_back(value val) {\n const auto& named = *val.named_arg;\n map_[size_] = {named.name, named.template deserialize()};\n ++size_;\n }\n\n public:\n arg_map(const arg_map&) = delete;\n void operator=(const arg_map&) = delete;\n arg_map() : map_(nullptr), size_(0) {}\n void init(const basic_format_args& args);\n ~arg_map() { delete[] map_; }\n\n basic_format_arg find(basic_string_view name) const {\n // The list is unsorted, so just return the first matching name.\n for (entry *it = map_, *end = map_ + size_; it != end; ++it) {\n if (it->name == name) return it->arg;\n }\n return {};\n }\n};\n\n// A type-erased reference to an std::locale to avoid heavy include.\nclass locale_ref {\n private:\n const void* locale_; // A type-erased pointer to std::locale.\n\n public:\n locale_ref() : locale_(nullptr) {}\n template explicit locale_ref(const Locale& loc);\n\n explicit operator bool() const FMT_NOEXCEPT { return locale_ != nullptr; }\n\n template Locale get() const;\n};\n\ntemplate constexpr unsigned long long encode_types() { return 0; }\n\ntemplate \nconstexpr unsigned long long encode_types() {\n return static_cast(mapped_type_constant::value) |\n (encode_types() << packed_arg_bits);\n}\n\ntemplate \nFMT_CONSTEXPR basic_format_arg make_arg(const T& value) {\n basic_format_arg arg;\n arg.type_ = mapped_type_constant::value;\n arg.value_ = arg_mapper().map(value);\n return arg;\n}\n\ntemplate \ninline value make_arg(const T& val) {\n return arg_mapper().map(val);\n}\n\ntemplate \ninline basic_format_arg make_arg(const T& value) {\n return make_arg(value);\n}\n\ntemplate struct is_reference_wrapper : std::false_type {};\n\ntemplate \nstruct is_reference_wrapper> : std::true_type {};\n\nclass dynamic_arg_list {\n // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for\n // templates it doesn't complain about inability to deduce single translation\n // unit for placing vtable. So storage_node_base is made a fake template.\n template struct node {\n virtual ~node() = default;\n std::unique_ptr> next;\n };\n\n template struct typed_node : node<> {\n T value;\n\n template \n FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}\n\n template \n FMT_CONSTEXPR typed_node(const basic_string_view& arg)\n : value(arg.data(), arg.size()) {}\n };\n\n std::unique_ptr> head_;\n\n public:\n template const T& push(const Arg& arg) {\n auto node = std::unique_ptr>(new typed_node(arg));\n auto& value = node->value;\n node->next = std::move(head_);\n head_ = std::move(node);\n return value;\n }\n};\n} // namespace internal\n\n// Formatting context.\ntemplate class basic_format_context {\n public:\n /** The character type for the output. */\n using char_type = Char;\n\n private:\n OutputIt out_;\n basic_format_args args_;\n internal::arg_map map_;\n internal::locale_ref loc_;\n\n public:\n using iterator = OutputIt;\n using format_arg = basic_format_arg;\n template using formatter_type = formatter;\n\n basic_format_context(const basic_format_context&) = delete;\n void operator=(const basic_format_context&) = delete;\n /**\n Constructs a ``basic_format_context`` object. References to the arguments are\n stored in the object so make sure they have appropriate lifetimes.\n */\n basic_format_context(OutputIt out,\n basic_format_args ctx_args,\n internal::locale_ref loc = internal::locale_ref())\n : out_(out), args_(ctx_args), loc_(loc) {}\n\n format_arg arg(int id) const { return args_.get(id); }\n\n // Checks if manual indexing is used and returns the argument with the\n // specified name.\n format_arg arg(basic_string_view name);\n\n internal::error_handler error_handler() { return {}; }\n void on_error(const char* message) { error_handler().on_error(message); }\n\n // Returns an iterator to the beginning of the output range.\n iterator out() { return out_; }\n\n // Advances the begin iterator to ``it``.\n void advance_to(iterator it) { out_ = it; }\n\n internal::locale_ref locale() { return loc_; }\n};\n\ntemplate \nusing buffer_context =\n basic_format_context>,\n Char>;\nusing format_context = buffer_context;\nusing wformat_context = buffer_context;\n\n/**\n \\rst\n An array of references to arguments. It can be implicitly converted into\n `~fmt::basic_format_args` for passing into type-erased formatting functions\n such as `~fmt::vformat`.\n \\endrst\n */\ntemplate \nclass format_arg_store\n#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409\n // Workaround a GCC template argument substitution bug.\n : public basic_format_args\n#endif\n{\n private:\n static const size_t num_args = sizeof...(Args);\n static const bool is_packed = num_args < internal::max_packed_args;\n\n using value_type = conditional_t,\n basic_format_arg>;\n\n // If the arguments are not packed, add one more element to mark the end.\n value_type data_[num_args + (num_args == 0 ? 1 : 0)];\n\n friend class basic_format_args;\n\n public:\n static constexpr unsigned long long types =\n is_packed ? internal::encode_types()\n : internal::is_unpacked_bit | num_args;\n\n format_arg_store(const Args&... args)\n :\n#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409\n basic_format_args(*this),\n#endif\n data_{internal::make_arg(args)...} {\n }\n};\n\n/**\n \\rst\n Constructs an `~fmt::format_arg_store` object that contains references to\n arguments and can be implicitly converted to `~fmt::format_args`. `Context`\n can be omitted in which case it defaults to `~fmt::context`.\n See `~fmt::arg` for lifetime considerations.\n \\endrst\n */\ntemplate \ninline format_arg_store make_format_args(\n const Args&... args) {\n return {args...};\n}\n\n/**\n \\rst\n A dynamic version of `fmt::format_arg_store<>`.\n It's equipped with a storage to potentially temporary objects which lifetime\n could be shorter than the format arguments object.\n\n It can be implicitly converted into `~fmt::basic_format_args` for passing\n into type-erased formatting functions such as `~fmt::vformat`.\n \\endrst\n */\ntemplate \nclass dynamic_format_arg_store\n#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409\n // Workaround a GCC template argument substitution bug.\n : public basic_format_args\n#endif\n{\n private:\n using char_type = typename Context::char_type;\n\n template struct need_copy {\n static constexpr internal::type mapped_type =\n internal::mapped_type_constant::value;\n\n enum {\n value = !(internal::is_reference_wrapper::value ||\n std::is_same>::value ||\n std::is_same>::value ||\n (mapped_type != internal::type::cstring_type &&\n mapped_type != internal::type::string_type &&\n mapped_type != internal::type::custom_type &&\n mapped_type != internal::type::named_arg_type))\n };\n };\n\n template \n using stored_type = conditional_t::value,\n std::basic_string, T>;\n\n // Storage of basic_format_arg must be contiguous.\n std::vector> data_;\n\n // Storage of arguments not fitting into basic_format_arg must grow\n // without relocation because items in data_ refer to it.\n internal::dynamic_arg_list dynamic_args_;\n\n friend class basic_format_args;\n\n unsigned long long get_types() const {\n return internal::is_unpacked_bit | data_.size();\n }\n\n template void emplace_arg(const T& arg) {\n data_.emplace_back(internal::make_arg(arg));\n }\n\n public:\n /**\n \\rst\n Adds an argument into the dynamic store for later passing to a formating\n function.\n\n Note that custom types and string types (but not string views!) are copied\n into the store with dynamic memory (in addition to resizing vector).\n\n **Example**::\n\n fmt::dynamic_format_arg_store store;\n store.push_back(42);\n store.push_back(\"abc\");\n store.push_back(1.5f);\n std::string result = fmt::vformat(\"{} and {} and {}\", store);\n \\endrst\n */\n template void push_back(const T& arg) {\n static_assert(\n !std::is_base_of, T>::value,\n \"named arguments are not supported yet\");\n if (internal::const_check(need_copy::value))\n emplace_arg(dynamic_args_.push>(arg));\n else\n emplace_arg(arg);\n }\n\n /**\n Adds a reference to the argument into the dynamic store for later passing to\n a formating function.\n */\n template void push_back(std::reference_wrapper arg) {\n static_assert(\n need_copy::value,\n \"objects of built-in types and string views are always copied\");\n emplace_arg(arg.get());\n }\n};\n\n/**\n \\rst\n A view of a collection of formatting arguments. To avoid lifetime issues it\n should only be used as a parameter type in type-erased functions such as\n ``vformat``::\n\n void vlog(string_view format_str, format_args args); // OK\n format_args args = make_format_args(42); // Error: dangling reference\n \\endrst\n */\ntemplate class basic_format_args {\n public:\n using size_type = int;\n using format_arg = basic_format_arg;\n\n private:\n // To reduce compiled code size per formatting function call, types of first\n // max_packed_args arguments are passed in the types_ field.\n unsigned long long types_;\n union {\n // If the number of arguments is less than max_packed_args, the argument\n // values are stored in values_, otherwise they are stored in args_.\n // This is done to reduce compiled code size as storing larger objects\n // may require more code (at least on x86-64) even if the same amount of\n // data is actually copied to stack. It saves ~10% on the bloat test.\n const internal::value* values_;\n const format_arg* args_;\n };\n\n bool is_packed() const { return (types_ & internal::is_unpacked_bit) == 0; }\n\n internal::type type(int index) const {\n int shift = index * internal::packed_arg_bits;\n unsigned int mask = (1 << internal::packed_arg_bits) - 1;\n return static_cast((types_ >> shift) & mask);\n }\n\n friend class internal::arg_map;\n\n void set_data(const internal::value* values) { values_ = values; }\n void set_data(const format_arg* args) { args_ = args; }\n\n format_arg do_get(int index) const {\n format_arg arg;\n if (!is_packed()) {\n auto num_args = max_size();\n if (index < num_args) arg = args_[index];\n return arg;\n }\n if (index > internal::max_packed_args) return arg;\n arg.type_ = type(index);\n if (arg.type_ == internal::type::none_type) return arg;\n internal::value& val = arg.value_;\n val = values_[index];\n return arg;\n }\n\n public:\n basic_format_args() : types_(0) {}\n\n /**\n \\rst\n Constructs a `basic_format_args` object from `~fmt::format_arg_store`.\n \\endrst\n */\n template \n basic_format_args(const format_arg_store& store)\n : types_(store.types) {\n set_data(store.data_);\n }\n\n /**\n \\rst\n Constructs a `basic_format_args` object from\n `~fmt::dynamic_format_arg_store`.\n \\endrst\n */\n basic_format_args(const dynamic_format_arg_store& store)\n : types_(store.get_types()) {\n set_data(store.data_.data());\n }\n\n /**\n \\rst\n Constructs a `basic_format_args` object from a dynamic set of arguments.\n \\endrst\n */\n basic_format_args(const format_arg* args, int count)\n : types_(internal::is_unpacked_bit | internal::to_unsigned(count)) {\n set_data(args);\n }\n\n /** Returns the argument at specified index. */\n format_arg get(int index) const {\n format_arg arg = do_get(index);\n if (arg.type_ == internal::type::named_arg_type)\n arg = arg.value_.named_arg->template deserialize();\n return arg;\n }\n\n int max_size() const {\n unsigned long long max_packed = internal::max_packed_args;\n return static_cast(is_packed() ? max_packed\n : types_ & ~internal::is_unpacked_bit);\n }\n};\n\n/** An alias to ``basic_format_args``. */\n// It is a separate type rather than an alias to make symbols readable.\nstruct format_args : basic_format_args {\n template \n format_args(Args&&... args)\n : basic_format_args(static_cast(args)...) {}\n};\nstruct wformat_args : basic_format_args {\n template \n wformat_args(Args&&... args)\n : basic_format_args(static_cast(args)...) {}\n};\n\ntemplate struct is_contiguous : std::false_type {};\n\ntemplate \nstruct is_contiguous> : std::true_type {};\n\ntemplate \nstruct is_contiguous> : std::true_type {};\n\nnamespace internal {\n\ntemplate \nstruct is_contiguous_back_insert_iterator : std::false_type {};\ntemplate \nstruct is_contiguous_back_insert_iterator>\n : is_contiguous {};\n\ntemplate struct named_arg_base {\n basic_string_view name;\n\n // Serialized value.\n mutable char data[sizeof(basic_format_arg>)];\n\n named_arg_base(basic_string_view nm) : name(nm) {}\n\n template basic_format_arg deserialize() const {\n basic_format_arg arg;\n std::memcpy(&arg, data, sizeof(basic_format_arg));\n return arg;\n }\n};\n\nstruct view {};\n\ntemplate \nstruct named_arg : view, named_arg_base {\n const T& value;\n\n named_arg(basic_string_view name, const T& val)\n : named_arg_base(name), value(val) {}\n};\n\ntemplate ::value)>\ninline void check_format_string(const S&) {\n#if defined(FMT_ENFORCE_COMPILE_STRING)\n static_assert(is_compile_string::value,\n \"FMT_ENFORCE_COMPILE_STRING requires all format strings to \"\n \"utilize FMT_STRING() or fmt().\");\n#endif\n}\ntemplate ::value)>\nvoid check_format_string(S);\n\ntemplate struct bool_pack;\ntemplate \nusing all_true =\n std::is_same, bool_pack>;\n\ntemplate >\ninline format_arg_store, remove_reference_t...>\nmake_args_checked(const S& format_str,\n const remove_reference_t&... args) {\n static_assert(\n all_true<(!std::is_base_of>::value ||\n !std::is_reference::value)...>::value,\n \"passing views as lvalues is disallowed\");\n check_format_string(format_str);\n return {args...};\n}\n\ntemplate \nstd::basic_string vformat(\n basic_string_view format_str,\n basic_format_args>> args);\n\ntemplate \ntypename buffer_context::iterator vformat_to(\n buffer& buf, basic_string_view format_str,\n basic_format_args>> args);\n\ntemplate ::value)>\ninline void vprint_mojibake(std::FILE*, basic_string_view, const Args&) {}\n\nFMT_API void vprint_mojibake(std::FILE*, string_view, format_args);\n#ifndef _WIN32\ninline void vprint_mojibake(std::FILE*, string_view, format_args) {}\n#endif\n} // namespace internal\n\n/**\n \\rst\n Returns a named argument to be used in a formatting function. It should only\n be used in a call to a formatting function.\n\n **Example**::\n\n fmt::print(\"Elapsed time: {s:.2f} seconds\", fmt::arg(\"s\", 1.23));\n \\endrst\n */\ntemplate >\ninline internal::named_arg arg(const S& name, const T& arg) {\n static_assert(internal::is_string::value, \"\");\n return {name, arg};\n}\n\n// Disable nested named arguments, e.g. ``arg(\"a\", arg(\"b\", 42))``.\ntemplate \nvoid arg(S, internal::named_arg) = delete;\n\n/** Formats a string and writes the output to ``out``. */\n// GCC 8 and earlier cannot handle std::back_insert_iterator with\n// vformat_to(...) overload, so SFINAE on iterator type instead.\ntemplate ,\n FMT_ENABLE_IF(\n internal::is_contiguous_back_insert_iterator::value)>\nOutputIt vformat_to(\n OutputIt out, const S& format_str,\n basic_format_args>> args) {\n using container = remove_reference_t;\n internal::container_buffer buf((internal::get_container(out)));\n internal::vformat_to(buf, to_string_view(format_str), args);\n return out;\n}\n\ntemplate ::value&& internal::is_string::value)>\ninline std::back_insert_iterator format_to(\n std::back_insert_iterator out, const S& format_str,\n Args&&... args) {\n return vformat_to(out, to_string_view(format_str),\n internal::make_args_checked(format_str, args...));\n}\n\ntemplate >\ninline std::basic_string vformat(\n const S& format_str,\n basic_format_args>> args) {\n return internal::vformat(to_string_view(format_str), args);\n}\n\n/**\n \\rst\n Formats arguments and returns the result as a string.\n\n **Example**::\n\n #include \n std::string message = fmt::format(\"The answer is {}\", 42);\n \\endrst\n*/\n// Pass char_t as a default template parameter instead of using\n// std::basic_string> to reduce the symbol size.\ntemplate >\ninline std::basic_string format(const S& format_str, Args&&... args) {\n return internal::vformat(\n to_string_view(format_str),\n internal::make_args_checked(format_str, args...));\n}\n\nFMT_API void vprint(string_view, format_args);\nFMT_API void vprint(std::FILE*, string_view, format_args);\n\n/**\n \\rst\n Formats ``args`` according to specifications in ``format_str`` and writes the\n output to the file ``f``. Strings are assumed to be Unicode-encoded unless the\n ``FMT_UNICODE`` macro is set to 0.\n\n **Example**::\n\n fmt::print(stderr, \"Don't {}!\", \"panic\");\n \\endrst\n */\ntemplate >\ninline void print(std::FILE* f, const S& format_str, Args&&... args) {\n return internal::is_unicode()\n ? vprint(f, to_string_view(format_str),\n internal::make_args_checked(format_str, args...))\n : internal::vprint_mojibake(\n f, to_string_view(format_str),\n internal::make_args_checked(format_str, args...));\n}\n\n/**\n \\rst\n Formats ``args`` according to specifications in ``format_str`` and writes\n the output to ``stdout``. Strings are assumed to be Unicode-encoded unless\n the ``FMT_UNICODE`` macro is set to 0.\n\n **Example**::\n\n fmt::print(\"Elapsed time: {0:.2f} seconds\", 1.23);\n \\endrst\n */\ntemplate >\ninline void print(const S& format_str, Args&&... args) {\n return internal::is_unicode()\n ? vprint(to_string_view(format_str),\n internal::make_args_checked(format_str, args...))\n : internal::vprint_mojibake(\n stdout, to_string_view(format_str),\n internal::make_args_checked(format_str, args...));\n}\nFMT_END_NAMESPACE\n\n#endif // FMT_CORE_H_\n" }, { "path": "examples/lesson04/fig04_12/fmt/format-inl.h", "content": "// Formatting library for C++ - implementation\n//\n// Copyright (c) 2012 - 2016, Victor Zverovich\n// All rights reserved.\n//\n// For the license information refer to format.h.\n\n#ifndef FMT_FORMAT_INL_H_\n#define FMT_FORMAT_INL_H_\n\n#include \n#include \n#include \n#include \n#include \n#include // for std::memmove\n#include \n\n#include \"format.h\"\n#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)\n# include \n#endif\n\n#ifdef _WIN32\n# include \n# include \n#endif\n\n#ifdef _MSC_VER\n# pragma warning(push)\n# pragma warning(disable : 4702) // unreachable code\n#endif\n\n// Dummy implementations of strerror_r and strerror_s called if corresponding\n// system functions are not available.\ninline fmt::internal::null<> strerror_r(int, char*, ...) { return {}; }\ninline fmt::internal::null<> strerror_s(char*, std::size_t, ...) { return {}; }\n\nFMT_BEGIN_NAMESPACE\nnamespace internal {\n\nFMT_FUNC void assert_fail(const char* file, int line, const char* message) {\n print(stderr, \"{}:{}: assertion failed: {}\", file, line, message);\n std::abort();\n}\n\n#ifndef _MSC_VER\n# define FMT_SNPRINTF snprintf\n#else // _MSC_VER\ninline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {\n va_list args;\n va_start(args, format);\n int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);\n va_end(args);\n return result;\n}\n# define FMT_SNPRINTF fmt_snprintf\n#endif // _MSC_VER\n\n// A portable thread-safe version of strerror.\n// Sets buffer to point to a string describing the error code.\n// This can be either a pointer to a string stored in buffer,\n// or a pointer to some static immutable string.\n// Returns one of the following values:\n// 0 - success\n// ERANGE - buffer is not large enough to store the error message\n// other - failure\n// Buffer should be at least of size 1.\nFMT_FUNC int safe_strerror(int error_code, char*& buffer,\n std::size_t buffer_size) FMT_NOEXCEPT {\n FMT_ASSERT(buffer != nullptr && buffer_size != 0, \"invalid buffer\");\n\n class dispatcher {\n private:\n int error_code_;\n char*& buffer_;\n std::size_t buffer_size_;\n\n // A noop assignment operator to avoid bogus warnings.\n void operator=(const dispatcher&) {}\n\n // Handle the result of XSI-compliant version of strerror_r.\n int handle(int result) {\n // glibc versions before 2.13 return result in errno.\n return result == -1 ? errno : result;\n }\n\n // Handle the result of GNU-specific version of strerror_r.\n FMT_MAYBE_UNUSED\n int handle(char* message) {\n // If the buffer is full then the message is probably truncated.\n if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)\n return ERANGE;\n buffer_ = message;\n return 0;\n }\n\n // Handle the case when strerror_r is not available.\n FMT_MAYBE_UNUSED\n int handle(internal::null<>) {\n return fallback(strerror_s(buffer_, buffer_size_, error_code_));\n }\n\n // Fallback to strerror_s when strerror_r is not available.\n FMT_MAYBE_UNUSED\n int fallback(int result) {\n // If the buffer is full then the message is probably truncated.\n return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE\n : result;\n }\n\n#if !FMT_MSC_VER\n // Fallback to strerror if strerror_r and strerror_s are not available.\n int fallback(internal::null<>) {\n errno = 0;\n buffer_ = strerror(error_code_);\n return errno;\n }\n#endif\n\n public:\n dispatcher(int err_code, char*& buf, std::size_t buf_size)\n : error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}\n\n int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }\n };\n return dispatcher(error_code, buffer, buffer_size).run();\n}\n\nFMT_FUNC void format_error_code(internal::buffer& out, int error_code,\n string_view message) FMT_NOEXCEPT {\n // Report error code making sure that the output fits into\n // inline_buffer_size to avoid dynamic memory allocation and potential\n // bad_alloc.\n out.resize(0);\n static const char SEP[] = \": \";\n static const char ERROR_STR[] = \"error \";\n // Subtract 2 to account for terminating null characters in SEP and ERROR_STR.\n std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;\n auto abs_value = static_cast>(error_code);\n if (internal::is_negative(error_code)) {\n abs_value = 0 - abs_value;\n ++error_code_size;\n }\n error_code_size += internal::to_unsigned(internal::count_digits(abs_value));\n internal::writer w(out);\n if (message.size() <= inline_buffer_size - error_code_size) {\n w.write(message);\n w.write(SEP);\n }\n w.write(ERROR_STR);\n w.write(error_code);\n assert(out.size() <= inline_buffer_size);\n}\n\nFMT_FUNC void report_error(format_func func, int error_code,\n string_view message) FMT_NOEXCEPT {\n memory_buffer full_message;\n func(full_message, error_code, message);\n // Don't use fwrite_fully because the latter may throw.\n (void)std::fwrite(full_message.data(), full_message.size(), 1, stderr);\n std::fputc('\\n', stderr);\n}\n\n// A wrapper around fwrite that throws on error.\nFMT_FUNC void fwrite_fully(const void* ptr, size_t size, size_t count,\n FILE* stream) {\n size_t written = std::fwrite(ptr, size, count, stream);\n if (written < count) FMT_THROW(system_error(errno, \"cannot write to file\"));\n}\n} // namespace internal\n\n#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)\nnamespace internal {\n\ntemplate \nlocale_ref::locale_ref(const Locale& loc) : locale_(&loc) {\n static_assert(std::is_same::value, \"\");\n}\n\ntemplate Locale locale_ref::get() const {\n static_assert(std::is_same::value, \"\");\n return locale_ ? *static_cast(locale_) : std::locale();\n}\n\ntemplate FMT_FUNC std::string grouping_impl(locale_ref loc) {\n return std::use_facet>(loc.get()).grouping();\n}\ntemplate FMT_FUNC Char thousands_sep_impl(locale_ref loc) {\n return std::use_facet>(loc.get())\n .thousands_sep();\n}\ntemplate FMT_FUNC Char decimal_point_impl(locale_ref loc) {\n return std::use_facet>(loc.get())\n .decimal_point();\n}\n} // namespace internal\n#else\ntemplate \nFMT_FUNC std::string internal::grouping_impl(locale_ref) {\n return \"\\03\";\n}\ntemplate \nFMT_FUNC Char internal::thousands_sep_impl(locale_ref) {\n return FMT_STATIC_THOUSANDS_SEPARATOR;\n}\ntemplate \nFMT_FUNC Char internal::decimal_point_impl(locale_ref) {\n return '.';\n}\n#endif\n\nFMT_API FMT_FUNC format_error::~format_error() FMT_NOEXCEPT = default;\nFMT_API FMT_FUNC system_error::~system_error() FMT_NOEXCEPT = default;\n\nFMT_FUNC void system_error::init(int err_code, string_view format_str,\n format_args args) {\n error_code_ = err_code;\n memory_buffer buffer;\n format_system_error(buffer, err_code, vformat(format_str, args));\n std::runtime_error& base = *this;\n base = std::runtime_error(to_string(buffer));\n}\n\nnamespace internal {\n\ntemplate <> FMT_FUNC int count_digits<4>(internal::fallback_uintptr n) {\n // fallback_uintptr is always stored in little endian.\n int i = static_cast(sizeof(void*)) - 1;\n while (i > 0 && n.value[i] == 0) --i;\n auto char_digits = std::numeric_limits::digits / 4;\n return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;\n}\n\ntemplate \nconst char basic_data::digits[] =\n \"0001020304050607080910111213141516171819\"\n \"2021222324252627282930313233343536373839\"\n \"4041424344454647484950515253545556575859\"\n \"6061626364656667686970717273747576777879\"\n \"8081828384858687888990919293949596979899\";\n\ntemplate \nconst char basic_data::hex_digits[] = \"0123456789abcdef\";\n\n#define FMT_POWERS_OF_10(factor) \\\n factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \\\n (factor)*1000000, (factor)*10000000, (factor)*100000000, \\\n (factor)*1000000000\n\ntemplate \nconst uint64_t basic_data::powers_of_10_64[] = {\n 1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),\n 10000000000000000000ULL};\n\ntemplate \nconst uint32_t basic_data::zero_or_powers_of_10_32[] = {0,\n FMT_POWERS_OF_10(1)};\n\ntemplate \nconst uint64_t basic_data::zero_or_powers_of_10_64[] = {\n 0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),\n 10000000000000000000ULL};\n\n// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.\n// These are generated by support/compute-powers.py.\ntemplate \nconst uint64_t basic_data::pow10_significands[] = {\n 0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,\n 0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,\n 0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,\n 0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,\n 0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,\n 0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,\n 0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,\n 0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,\n 0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,\n 0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,\n 0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,\n 0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,\n 0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,\n 0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,\n 0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,\n 0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,\n 0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,\n 0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,\n 0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,\n 0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,\n 0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,\n 0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,\n 0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,\n 0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,\n 0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,\n 0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,\n 0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,\n 0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,\n 0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,\n};\n\n// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding\n// to significands above.\ntemplate \nconst int16_t basic_data::pow10_exponents[] = {\n -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,\n -927, -901, -874, -847, -821, -794, -768, -741, -715, -688, -661,\n -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369,\n -343, -316, -289, -263, -236, -210, -183, -157, -130, -103, -77,\n -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216,\n 242, 269, 295, 322, 348, 375, 402, 428, 455, 481, 508,\n 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800,\n 827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066};\n\ntemplate \nconst char basic_data::foreground_color[] = \"\\x1b[38;2;\";\ntemplate \nconst char basic_data::background_color[] = \"\\x1b[48;2;\";\ntemplate const char basic_data::reset_color[] = \"\\x1b[0m\";\ntemplate const wchar_t basic_data::wreset_color[] = L\"\\x1b[0m\";\ntemplate const char basic_data::signs[] = {0, '-', '+', ' '};\n\ntemplate struct bits {\n static FMT_CONSTEXPR_DECL const int value =\n static_cast(sizeof(T) * std::numeric_limits::digits);\n};\n\nclass fp;\ntemplate fp normalize(fp value);\n\n// Lower (upper) boundary is a value half way between a floating-point value\n// and its predecessor (successor). Boundaries have the same exponent as the\n// value so only significands are stored.\nstruct boundaries {\n uint64_t lower;\n uint64_t upper;\n};\n\n// A handmade floating-point number f * pow(2, e).\nclass fp {\n private:\n using significand_type = uint64_t;\n\n public:\n significand_type f;\n int e;\n\n // All sizes are in bits.\n // Subtract 1 to account for an implicit most significant bit in the\n // normalized form.\n static FMT_CONSTEXPR_DECL const int double_significand_size =\n std::numeric_limits::digits - 1;\n static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =\n 1ULL << double_significand_size;\n static FMT_CONSTEXPR_DECL const int significand_size =\n bits::value;\n\n fp() : f(0), e(0) {}\n fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}\n\n // Constructs fp from an IEEE754 double. It is a template to prevent compile\n // errors on platforms where double is not IEEE754.\n template explicit fp(Double d) { assign(d); }\n\n // Assigns d to this and return true iff predecessor is closer than successor.\n template \n bool assign(Double d) {\n // Assume double is in the format [sign][exponent][significand].\n using limits = std::numeric_limits;\n const int exponent_size =\n bits::value - double_significand_size - 1; // -1 for sign\n const uint64_t significand_mask = implicit_bit - 1;\n const uint64_t exponent_mask = (~0ULL >> 1) & ~significand_mask;\n const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;\n auto u = bit_cast(d);\n f = u & significand_mask;\n int biased_e =\n static_cast((u & exponent_mask) >> double_significand_size);\n // Predecessor is closer if d is a normalized power of 2 (f == 0) other than\n // the smallest normalized number (biased_e > 1).\n bool is_predecessor_closer = f == 0 && biased_e > 1;\n if (biased_e != 0)\n f += implicit_bit;\n else\n biased_e = 1; // Subnormals use biased exponent 1 (min exponent).\n e = biased_e - exponent_bias - double_significand_size;\n return is_predecessor_closer;\n }\n\n template \n bool assign(Double) {\n *this = fp();\n return false;\n }\n\n // Assigns d to this together with computing lower and upper boundaries,\n // where a boundary is a value half way between the number and its predecessor\n // (lower) or successor (upper). The upper boundary is normalized and lower\n // has the same exponent but may be not normalized.\n template boundaries assign_with_boundaries(Double d) {\n bool is_lower_closer = assign(d);\n fp lower =\n is_lower_closer ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);\n // 1 in normalize accounts for the exponent shift above.\n fp upper = normalize<1>(fp((f << 1) + 1, e - 1));\n lower.f <<= lower.e - upper.e;\n return boundaries{lower.f, upper.f};\n }\n\n template boundaries assign_float_with_boundaries(Double d) {\n assign(d);\n constexpr int min_normal_e = std::numeric_limits::min_exponent -\n std::numeric_limits::digits;\n significand_type half_ulp = 1 << (std::numeric_limits::digits -\n std::numeric_limits::digits - 1);\n if (min_normal_e > e) half_ulp <<= min_normal_e - e;\n fp upper = normalize<0>(fp(f + half_ulp, e));\n fp lower = fp(\n f - (half_ulp >> ((f == implicit_bit && e > min_normal_e) ? 1 : 0)), e);\n lower.f <<= lower.e - upper.e;\n return boundaries{lower.f, upper.f};\n }\n};\n\n// Normalizes the value converted from double and multiplied by (1 << SHIFT).\ntemplate fp normalize(fp value) {\n // Handle subnormals.\n const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;\n while ((value.f & shifted_implicit_bit) == 0) {\n value.f <<= 1;\n --value.e;\n }\n // Subtract 1 to account for hidden bit.\n const auto offset =\n fp::significand_size - fp::double_significand_size - SHIFT - 1;\n value.f <<= offset;\n value.e -= offset;\n return value;\n}\n\ninline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; }\n\n// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.\ninline uint64_t multiply(uint64_t lhs, uint64_t rhs) {\n#if FMT_USE_INT128\n auto product = static_cast<__uint128_t>(lhs) * rhs;\n auto f = static_cast(product >> 64);\n return (static_cast(product) & (1ULL << 63)) != 0 ? f + 1 : f;\n#else\n // Multiply 32-bit parts of significands.\n uint64_t mask = (1ULL << 32) - 1;\n uint64_t a = lhs >> 32, b = lhs & mask;\n uint64_t c = rhs >> 32, d = rhs & mask;\n uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;\n // Compute mid 64-bit of result and round.\n uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);\n return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);\n#endif\n}\n\ninline fp operator*(fp x, fp y) { return {multiply(x.f, y.f), x.e + y.e + 64}; }\n\n// Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its\n// (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.\ninline fp get_cached_power(int min_exponent, int& pow10_exponent) {\n const int64_t one_over_log2_10 = 0x4d104d42; // round(pow(2, 32) / log2(10))\n int index = static_cast(\n ((min_exponent + fp::significand_size - 1) * one_over_log2_10 +\n ((int64_t(1) << 32) - 1)) // ceil\n >> 32 // arithmetic shift\n );\n // Decimal exponent of the first (smallest) cached power of 10.\n const int first_dec_exp = -348;\n // Difference between 2 consecutive decimal exponents in cached powers of 10.\n const int dec_exp_step = 8;\n index = (index - first_dec_exp - 1) / dec_exp_step + 1;\n pow10_exponent = first_dec_exp + index * dec_exp_step;\n return {data::pow10_significands[index], data::pow10_exponents[index]};\n}\n\n// A simple accumulator to hold the sums of terms in bigint::square if uint128_t\n// is not available.\nstruct accumulator {\n uint64_t lower;\n uint64_t upper;\n\n accumulator() : lower(0), upper(0) {}\n explicit operator uint32_t() const { return static_cast(lower); }\n\n void operator+=(uint64_t n) {\n lower += n;\n if (lower < n) ++upper;\n }\n void operator>>=(int shift) {\n assert(shift == 32);\n (void)shift;\n lower = (upper << 32) | (lower >> 32);\n upper >>= 32;\n }\n};\n\nclass bigint {\n private:\n // A bigint is stored as an array of bigits (big digits), with bigit at index\n // 0 being the least significant one.\n using bigit = uint32_t;\n using double_bigit = uint64_t;\n enum { bigits_capacity = 32 };\n basic_memory_buffer bigits_;\n int exp_;\n\n bigit operator[](int index) const { return bigits_[to_unsigned(index)]; }\n bigit& operator[](int index) { return bigits_[to_unsigned(index)]; }\n\n static FMT_CONSTEXPR_DECL const int bigit_bits = bits::value;\n\n friend struct formatter;\n\n void subtract_bigits(int index, bigit other, bigit& borrow) {\n auto result = static_cast((*this)[index]) - other - borrow;\n (*this)[index] = static_cast(result);\n borrow = static_cast(result >> (bigit_bits * 2 - 1));\n }\n\n void remove_leading_zeros() {\n int num_bigits = static_cast(bigits_.size()) - 1;\n while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;\n bigits_.resize(to_unsigned(num_bigits + 1));\n }\n\n // Computes *this -= other assuming aligned bigints and *this >= other.\n void subtract_aligned(const bigint& other) {\n FMT_ASSERT(other.exp_ >= exp_, \"unaligned bigints\");\n FMT_ASSERT(compare(*this, other) >= 0, \"\");\n bigit borrow = 0;\n int i = other.exp_ - exp_;\n for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j) {\n subtract_bigits(i, other.bigits_[j], borrow);\n }\n while (borrow > 0) subtract_bigits(i, 0, borrow);\n remove_leading_zeros();\n }\n\n void multiply(uint32_t value) {\n const double_bigit wide_value = value;\n bigit carry = 0;\n for (size_t i = 0, n = bigits_.size(); i < n; ++i) {\n double_bigit result = bigits_[i] * wide_value + carry;\n bigits_[i] = static_cast(result);\n carry = static_cast(result >> bigit_bits);\n }\n if (carry != 0) bigits_.push_back(carry);\n }\n\n void multiply(uint64_t value) {\n const bigit mask = ~bigit(0);\n const double_bigit lower = value & mask;\n const double_bigit upper = value >> bigit_bits;\n double_bigit carry = 0;\n for (size_t i = 0, n = bigits_.size(); i < n; ++i) {\n double_bigit result = bigits_[i] * lower + (carry & mask);\n carry =\n bigits_[i] * upper + (result >> bigit_bits) + (carry >> bigit_bits);\n bigits_[i] = static_cast(result);\n }\n while (carry != 0) {\n bigits_.push_back(carry & mask);\n carry >>= bigit_bits;\n }\n }\n\n public:\n bigint() : exp_(0) {}\n explicit bigint(uint64_t n) { assign(n); }\n ~bigint() { assert(bigits_.capacity() <= bigits_capacity); }\n\n bigint(const bigint&) = delete;\n void operator=(const bigint&) = delete;\n\n void assign(const bigint& other) {\n bigits_.resize(other.bigits_.size());\n auto data = other.bigits_.data();\n std::copy(data, data + other.bigits_.size(), bigits_.data());\n exp_ = other.exp_;\n }\n\n void assign(uint64_t n) {\n size_t num_bigits = 0;\n do {\n bigits_[num_bigits++] = n & ~bigit(0);\n n >>= bigit_bits;\n } while (n != 0);\n bigits_.resize(num_bigits);\n exp_ = 0;\n }\n\n int num_bigits() const { return static_cast(bigits_.size()) + exp_; }\n\n bigint& operator<<=(int shift) {\n assert(shift >= 0);\n exp_ += shift / bigit_bits;\n shift %= bigit_bits;\n if (shift == 0) return *this;\n bigit carry = 0;\n for (size_t i = 0, n = bigits_.size(); i < n; ++i) {\n bigit c = bigits_[i] >> (bigit_bits - shift);\n bigits_[i] = (bigits_[i] << shift) + carry;\n carry = c;\n }\n if (carry != 0) bigits_.push_back(carry);\n return *this;\n }\n\n template bigint& operator*=(Int value) {\n FMT_ASSERT(value > 0, \"\");\n multiply(uint32_or_64_or_128_t(value));\n return *this;\n }\n\n friend int compare(const bigint& lhs, const bigint& rhs) {\n int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();\n if (num_lhs_bigits != num_rhs_bigits)\n return num_lhs_bigits > num_rhs_bigits ? 1 : -1;\n int i = static_cast(lhs.bigits_.size()) - 1;\n int j = static_cast(rhs.bigits_.size()) - 1;\n int end = i - j;\n if (end < 0) end = 0;\n for (; i >= end; --i, --j) {\n bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j];\n if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1;\n }\n if (i != j) return i > j ? 1 : -1;\n return 0;\n }\n\n // Returns compare(lhs1 + lhs2, rhs).\n friend int add_compare(const bigint& lhs1, const bigint& lhs2,\n const bigint& rhs) {\n int max_lhs_bigits = (std::max)(lhs1.num_bigits(), lhs2.num_bigits());\n int num_rhs_bigits = rhs.num_bigits();\n if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;\n if (max_lhs_bigits > num_rhs_bigits) return 1;\n auto get_bigit = [](const bigint& n, int i) -> bigit {\n return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0;\n };\n double_bigit borrow = 0;\n int min_exp = (std::min)((std::min)(lhs1.exp_, lhs2.exp_), rhs.exp_);\n for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {\n double_bigit sum =\n static_cast(get_bigit(lhs1, i)) + get_bigit(lhs2, i);\n bigit rhs_bigit = get_bigit(rhs, i);\n if (sum > rhs_bigit + borrow) return 1;\n borrow = rhs_bigit + borrow - sum;\n if (borrow > 1) return -1;\n borrow <<= bigit_bits;\n }\n return borrow != 0 ? -1 : 0;\n }\n\n // Assigns pow(10, exp) to this bigint.\n void assign_pow10(int exp) {\n assert(exp >= 0);\n if (exp == 0) return assign(1);\n // Find the top bit.\n int bitmask = 1;\n while (exp >= bitmask) bitmask <<= 1;\n bitmask >>= 1;\n // pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by\n // repeated squaring and multiplication.\n assign(5);\n bitmask >>= 1;\n while (bitmask != 0) {\n square();\n if ((exp & bitmask) != 0) *this *= 5;\n bitmask >>= 1;\n }\n *this <<= exp; // Multiply by pow(2, exp) by shifting.\n }\n\n void square() {\n basic_memory_buffer n(std::move(bigits_));\n int num_bigits = static_cast(bigits_.size());\n int num_result_bigits = 2 * num_bigits;\n bigits_.resize(to_unsigned(num_result_bigits));\n using accumulator_t = conditional_t;\n auto sum = accumulator_t();\n for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {\n // Compute bigit at position bigit_index of the result by adding\n // cross-product terms n[i] * n[j] such that i + j == bigit_index.\n for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {\n // Most terms are multiplied twice which can be optimized in the future.\n sum += static_cast(n[i]) * n[j];\n }\n (*this)[bigit_index] = static_cast(sum);\n sum >>= bits::value; // Compute the carry.\n }\n // Do the same for the top half.\n for (int bigit_index = num_bigits; bigit_index < num_result_bigits;\n ++bigit_index) {\n for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)\n sum += static_cast(n[i++]) * n[j--];\n (*this)[bigit_index] = static_cast(sum);\n sum >>= bits::value;\n }\n --num_result_bigits;\n remove_leading_zeros();\n exp_ *= 2;\n }\n\n // Divides this bignum by divisor, assigning the remainder to this and\n // returning the quotient.\n int divmod_assign(const bigint& divisor) {\n FMT_ASSERT(this != &divisor, \"\");\n if (compare(*this, divisor) < 0) return 0;\n int num_bigits = static_cast(bigits_.size());\n FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, \"\");\n int exp_difference = exp_ - divisor.exp_;\n if (exp_difference > 0) {\n // Align bigints by adding trailing zeros to simplify subtraction.\n bigits_.resize(to_unsigned(num_bigits + exp_difference));\n for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)\n bigits_[j] = bigits_[i];\n std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);\n exp_ -= exp_difference;\n }\n int quotient = 0;\n do {\n subtract_aligned(divisor);\n ++quotient;\n } while (compare(*this, divisor) >= 0);\n return quotient;\n }\n};\n\nenum class round_direction { unknown, up, down };\n\n// Given the divisor (normally a power of 10), the remainder = v % divisor for\n// some number v and the error, returns whether v should be rounded up, down, or\n// whether the rounding direction can't be determined due to error.\n// error should be less than divisor / 2.\ninline round_direction get_round_direction(uint64_t divisor, uint64_t remainder,\n uint64_t error) {\n FMT_ASSERT(remainder < divisor, \"\"); // divisor - remainder won't overflow.\n FMT_ASSERT(error < divisor, \"\"); // divisor - error won't overflow.\n FMT_ASSERT(error < divisor - error, \"\"); // error * 2 won't overflow.\n // Round down if (remainder + error) * 2 <= divisor.\n if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)\n return round_direction::down;\n // Round up if (remainder - error) * 2 >= divisor.\n if (remainder >= error &&\n remainder - error >= divisor - (remainder - error)) {\n return round_direction::up;\n }\n return round_direction::unknown;\n}\n\nnamespace digits {\nenum result {\n more, // Generate more digits.\n done, // Done generating digits.\n error // Digit generation cancelled due to an error.\n};\n}\n\n// A version of count_digits optimized for grisu_gen_digits.\ninline int grisu_count_digits(uint32_t n) {\n if (n < 10) return 1;\n if (n < 100) return 2;\n if (n < 1000) return 3;\n if (n < 10000) return 4;\n if (n < 100000) return 5;\n if (n < 1000000) return 6;\n if (n < 10000000) return 7;\n if (n < 100000000) return 8;\n if (n < 1000000000) return 9;\n return 10;\n}\n\n// Generates output using the Grisu digit-gen algorithm.\n// error: the size of the region (lower, upper) outside of which numbers\n// definitely do not round to value (Delta in Grisu3).\ntemplate \nFMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error,\n int& exp, Handler& handler) {\n const fp one(1ULL << -value.e, value.e);\n // The integral part of scaled value (p1 in Grisu) = value / one. It cannot be\n // zero because it contains a product of two 64-bit numbers with MSB set (due\n // to normalization) - 1, shifted right by at most 60 bits.\n auto integral = static_cast(value.f >> -one.e);\n FMT_ASSERT(integral != 0, \"\");\n FMT_ASSERT(integral == value.f >> -one.e, \"\");\n // The fractional part of scaled value (p2 in Grisu) c = value % one.\n uint64_t fractional = value.f & (one.f - 1);\n exp = grisu_count_digits(integral); // kappa in Grisu.\n // Divide by 10 to prevent overflow.\n auto result = handler.on_start(data::powers_of_10_64[exp - 1] << -one.e,\n value.f / 10, error * 10, exp);\n if (result != digits::more) return result;\n // Generate digits for the integral part. This can produce up to 10 digits.\n do {\n uint32_t digit = 0;\n auto divmod_integral = [&](uint32_t divisor) {\n digit = integral / divisor;\n integral %= divisor;\n };\n // This optimization by Milo Yip reduces the number of integer divisions by\n // one per iteration.\n switch (exp) {\n case 10:\n divmod_integral(1000000000);\n break;\n case 9:\n divmod_integral(100000000);\n break;\n case 8:\n divmod_integral(10000000);\n break;\n case 7:\n divmod_integral(1000000);\n break;\n case 6:\n divmod_integral(100000);\n break;\n case 5:\n divmod_integral(10000);\n break;\n case 4:\n divmod_integral(1000);\n break;\n case 3:\n divmod_integral(100);\n break;\n case 2:\n divmod_integral(10);\n break;\n case 1:\n digit = integral;\n integral = 0;\n break;\n default:\n FMT_ASSERT(false, \"invalid number of digits\");\n }\n --exp;\n uint64_t remainder =\n (static_cast(integral) << -one.e) + fractional;\n result = handler.on_digit(static_cast('0' + digit),\n data::powers_of_10_64[exp] << -one.e, remainder,\n error, exp, true);\n if (result != digits::more) return result;\n } while (exp > 0);\n // Generate digits for the fractional part.\n for (;;) {\n fractional *= 10;\n error *= 10;\n char digit =\n static_cast('0' + static_cast(fractional >> -one.e));\n fractional &= one.f - 1;\n --exp;\n result = handler.on_digit(digit, one.f, fractional, error, exp, false);\n if (result != digits::more) return result;\n }\n}\n\n// The fixed precision digit handler.\nstruct fixed_handler {\n char* buf;\n int size;\n int precision;\n int exp10;\n bool fixed;\n\n digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error,\n int& exp) {\n // Non-fixed formats require at least one digit and no precision adjustment.\n if (!fixed) return digits::more;\n // Adjust fixed precision by exponent because it is relative to decimal\n // point.\n precision += exp + exp10;\n // Check if precision is satisfied just by leading zeros, e.g.\n // format(\"{:.2f}\", 0.001) gives \"0.00\" without generating any digits.\n if (precision > 0) return digits::more;\n if (precision < 0) return digits::done;\n auto dir = get_round_direction(divisor, remainder, error);\n if (dir == round_direction::unknown) return digits::error;\n buf[size++] = dir == round_direction::up ? '1' : '0';\n return digits::done;\n }\n\n digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,\n uint64_t error, int, bool integral) {\n FMT_ASSERT(remainder < divisor, \"\");\n buf[size++] = digit;\n if (size < precision) return digits::more;\n if (!integral) {\n // Check if error * 2 < divisor with overflow prevention.\n // The check is not needed for the integral part because error = 1\n // and divisor > (1 << 32) there.\n if (error >= divisor || error >= divisor - error) return digits::error;\n } else {\n FMT_ASSERT(error == 1 && divisor > 2, \"\");\n }\n auto dir = get_round_direction(divisor, remainder, error);\n if (dir != round_direction::up)\n return dir == round_direction::down ? digits::done : digits::error;\n ++buf[size - 1];\n for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {\n buf[i] = '0';\n ++buf[i - 1];\n }\n if (buf[0] > '9') {\n buf[0] = '1';\n buf[size++] = '0';\n }\n return digits::done;\n }\n};\n\n// The shortest representation digit handler.\nstruct grisu_shortest_handler {\n char* buf;\n int size;\n // Distance between scaled value and upper bound (wp_W in Grisu3).\n uint64_t diff;\n\n digits::result on_start(uint64_t, uint64_t, uint64_t, int&) {\n return digits::more;\n }\n\n // Decrement the generated number approaching value from above.\n void round(uint64_t d, uint64_t divisor, uint64_t& remainder,\n uint64_t error) {\n while (\n remainder < d && error - remainder >= divisor &&\n (remainder + divisor < d || d - remainder >= remainder + divisor - d)) {\n --buf[size - 1];\n remainder += divisor;\n }\n }\n\n // Implements Grisu's round_weed.\n digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,\n uint64_t error, int exp, bool integral) {\n buf[size++] = digit;\n if (remainder >= error) return digits::more;\n uint64_t unit = integral ? 1 : data::powers_of_10_64[-exp];\n uint64_t up = (diff - 1) * unit; // wp_Wup\n round(up, divisor, remainder, error);\n uint64_t down = (diff + 1) * unit; // wp_Wdown\n if (remainder < down && error - remainder >= divisor &&\n (remainder + divisor < down ||\n down - remainder > remainder + divisor - down)) {\n return digits::error;\n }\n return 2 * unit <= remainder && remainder <= error - 4 * unit\n ? digits::done\n : digits::error;\n }\n};\n\n// Formats value using a variation of the Fixed-Precision Positive\n// Floating-Point Printout ((FPP)^2) algorithm by Steele & White:\n// https://fmt.dev/p372-steele.pdf.\ntemplate \nvoid fallback_format(Double d, buffer& buf, int& exp10) {\n bigint numerator; // 2 * R in (FPP)^2.\n bigint denominator; // 2 * S in (FPP)^2.\n // lower and upper are differences between value and corresponding boundaries.\n bigint lower; // (M^- in (FPP)^2).\n bigint upper_store; // upper's value if different from lower.\n bigint* upper = nullptr; // (M^+ in (FPP)^2).\n fp value;\n // Shift numerator and denominator by an extra bit or two (if lower boundary\n // is closer) to make lower and upper integers. This eliminates multiplication\n // by 2 during later computations.\n // TODO: handle float\n int shift = value.assign(d) ? 2 : 1;\n uint64_t significand = value.f << shift;\n if (value.e >= 0) {\n numerator.assign(significand);\n numerator <<= value.e;\n lower.assign(1);\n lower <<= value.e;\n if (shift != 1) {\n upper_store.assign(1);\n upper_store <<= value.e + 1;\n upper = &upper_store;\n }\n denominator.assign_pow10(exp10);\n denominator <<= 1;\n } else if (exp10 < 0) {\n numerator.assign_pow10(-exp10);\n lower.assign(numerator);\n if (shift != 1) {\n upper_store.assign(numerator);\n upper_store <<= 1;\n upper = &upper_store;\n }\n numerator *= significand;\n denominator.assign(1);\n denominator <<= shift - value.e;\n } else {\n numerator.assign(significand);\n denominator.assign_pow10(exp10);\n denominator <<= shift - value.e;\n lower.assign(1);\n if (shift != 1) {\n upper_store.assign(1ULL << 1);\n upper = &upper_store;\n }\n }\n if (!upper) upper = &lower;\n // Invariant: value == (numerator / denominator) * pow(10, exp10).\n bool even = (value.f & 1) == 0;\n int num_digits = 0;\n char* data = buf.data();\n for (;;) {\n int digit = numerator.divmod_assign(denominator);\n bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower.\n // numerator + upper >[=] pow10:\n bool high = add_compare(numerator, *upper, denominator) + even > 0;\n data[num_digits++] = static_cast('0' + digit);\n if (low || high) {\n if (!low) {\n ++data[num_digits - 1];\n } else if (high) {\n int result = add_compare(numerator, numerator, denominator);\n // Round half to even.\n if (result > 0 || (result == 0 && (digit % 2) != 0))\n ++data[num_digits - 1];\n }\n buf.resize(to_unsigned(num_digits));\n exp10 -= num_digits - 1;\n return;\n }\n numerator *= 10;\n lower *= 10;\n if (upper != &lower) *upper *= 10;\n }\n}\n\n// Formats value using the Grisu algorithm\n// (https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf)\n// if T is a IEEE754 binary32 or binary64 and snprintf otherwise.\ntemplate \nint format_float(T value, int precision, float_specs specs, buffer& buf) {\n static_assert(!std::is_same::value, \"\");\n FMT_ASSERT(value >= 0, \"value is negative\");\n\n const bool fixed = specs.format == float_format::fixed;\n if (value <= 0) { // <= instead of == to silence a warning.\n if (precision <= 0 || !fixed) {\n buf.push_back('0');\n return 0;\n }\n buf.resize(to_unsigned(precision));\n std::uninitialized_fill_n(buf.data(), precision, '0');\n return -precision;\n }\n\n if (!specs.use_grisu) return snprintf_float(value, precision, specs, buf);\n\n int exp = 0;\n const int min_exp = -60; // alpha in Grisu.\n int cached_exp10 = 0; // K in Grisu.\n if (precision < 0) {\n fp fp_value;\n auto boundaries = specs.binary32\n ? fp_value.assign_float_with_boundaries(value)\n : fp_value.assign_with_boundaries(value);\n fp_value = normalize(fp_value);\n // Find a cached power of 10 such that multiplying value by it will bring\n // the exponent in the range [min_exp, -32].\n const fp cached_pow = get_cached_power(\n min_exp - (fp_value.e + fp::significand_size), cached_exp10);\n // Multiply value and boundaries by the cached power of 10.\n fp_value = fp_value * cached_pow;\n boundaries.lower = multiply(boundaries.lower, cached_pow.f);\n boundaries.upper = multiply(boundaries.upper, cached_pow.f);\n assert(min_exp <= fp_value.e && fp_value.e <= -32);\n --boundaries.lower; // \\tilde{M}^- - 1 ulp -> M^-_{\\downarrow}.\n ++boundaries.upper; // \\tilde{M}^+ + 1 ulp -> M^+_{\\uparrow}.\n // Numbers outside of (lower, upper) definitely do not round to value.\n grisu_shortest_handler handler{buf.data(), 0,\n boundaries.upper - fp_value.f};\n auto result =\n grisu_gen_digits(fp(boundaries.upper, fp_value.e),\n boundaries.upper - boundaries.lower, exp, handler);\n if (result == digits::error) {\n exp += handler.size - cached_exp10 - 1;\n fallback_format(value, buf, exp);\n return exp;\n }\n buf.resize(to_unsigned(handler.size));\n } else {\n if (precision > 17) return snprintf_float(value, precision, specs, buf);\n fp normalized = normalize(fp(value));\n const auto cached_pow = get_cached_power(\n min_exp - (normalized.e + fp::significand_size), cached_exp10);\n normalized = normalized * cached_pow;\n fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};\n if (grisu_gen_digits(normalized, 1, exp, handler) == digits::error)\n return snprintf_float(value, precision, specs, buf);\n int num_digits = handler.size;\n if (!fixed) {\n // Remove trailing zeros.\n while (num_digits > 0 && buf[num_digits - 1] == '0') {\n --num_digits;\n ++exp;\n }\n }\n buf.resize(to_unsigned(num_digits));\n }\n return exp - cached_exp10;\n}\n\ntemplate \nint snprintf_float(T value, int precision, float_specs specs,\n buffer& buf) {\n // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.\n FMT_ASSERT(buf.capacity() > buf.size(), \"empty buffer\");\n static_assert(!std::is_same::value, \"\");\n\n // Subtract 1 to account for the difference in precision since we use %e for\n // both general and exponent format.\n if (specs.format == float_format::general ||\n specs.format == float_format::exp)\n precision = (precision >= 0 ? precision : 6) - 1;\n\n // Build the format string.\n enum { max_format_size = 7 }; // Ths longest format is \"%#.*Le\".\n char format[max_format_size];\n char* format_ptr = format;\n *format_ptr++ = '%';\n if (specs.showpoint && specs.format == float_format::hex) *format_ptr++ = '#';\n if (precision >= 0) {\n *format_ptr++ = '.';\n *format_ptr++ = '*';\n }\n if (std::is_same()) *format_ptr++ = 'L';\n *format_ptr++ = specs.format != float_format::hex\n ? (specs.format == float_format::fixed ? 'f' : 'e')\n : (specs.upper ? 'A' : 'a');\n *format_ptr = '\\0';\n\n // Format using snprintf.\n auto offset = buf.size();\n for (;;) {\n auto begin = buf.data() + offset;\n auto capacity = buf.capacity() - offset;\n#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION\n if (precision > 100000)\n throw std::runtime_error(\n \"fuzz mode - avoid large allocation inside snprintf\");\n#endif\n // Suppress the warning about a nonliteral format string.\n // Cannot use auto becase of a bug in MinGW (#1532).\n int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;\n int result = precision >= 0\n ? snprintf_ptr(begin, capacity, format, precision, value)\n : snprintf_ptr(begin, capacity, format, value);\n if (result < 0) {\n buf.reserve(buf.capacity() + 1); // The buffer will grow exponentially.\n continue;\n }\n auto size = to_unsigned(result);\n // Size equal to capacity means that the last character was truncated.\n if (size >= capacity) {\n buf.reserve(size + offset + 1); // Add 1 for the terminating '\\0'.\n continue;\n }\n auto is_digit = [](char c) { return c >= '0' && c <= '9'; };\n if (specs.format == float_format::fixed) {\n if (precision == 0) {\n buf.resize(size);\n return 0;\n }\n // Find and remove the decimal point.\n auto end = begin + size, p = end;\n do {\n --p;\n } while (is_digit(*p));\n int fraction_size = static_cast(end - p - 1);\n std::memmove(p, p + 1, to_unsigned(fraction_size));\n buf.resize(size - 1);\n return -fraction_size;\n }\n if (specs.format == float_format::hex) {\n buf.resize(size + offset);\n return 0;\n }\n // Find and parse the exponent.\n auto end = begin + size, exp_pos = end;\n do {\n --exp_pos;\n } while (*exp_pos != 'e');\n char sign = exp_pos[1];\n assert(sign == '+' || sign == '-');\n int exp = 0;\n auto p = exp_pos + 2; // Skip 'e' and sign.\n do {\n assert(is_digit(*p));\n exp = exp * 10 + (*p++ - '0');\n } while (p != end);\n if (sign == '-') exp = -exp;\n int fraction_size = 0;\n if (exp_pos != begin + 1) {\n // Remove trailing zeros.\n auto fraction_end = exp_pos - 1;\n while (*fraction_end == '0') --fraction_end;\n // Move the fractional part left to get rid of the decimal point.\n fraction_size = static_cast(fraction_end - begin - 1);\n std::memmove(begin + 1, begin + 2, to_unsigned(fraction_size));\n }\n buf.resize(to_unsigned(fraction_size) + offset + 1);\n return exp - fraction_size;\n }\n}\n\n// A public domain branchless UTF-8 decoder by Christopher Wellons:\n// https://github.com/skeeto/branchless-utf8\n/* Decode the next character, c, from buf, reporting errors in e.\n *\n * Since this is a branchless decoder, four bytes will be read from the\n * buffer regardless of the actual length of the next character. This\n * means the buffer _must_ have at least three bytes of zero padding\n * following the end of the data stream.\n *\n * Errors are reported in e, which will be non-zero if the parsed\n * character was somehow invalid: invalid byte sequence, non-canonical\n * encoding, or a surrogate half.\n *\n * The function returns a pointer to the next character. When an error\n * occurs, this pointer will be a guess that depends on the particular\n * error, but it will always advance at least one byte.\n */\nFMT_FUNC const char* utf8_decode(const char* buf, uint32_t* c, int* e) {\n static const char lengths[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,\n 0, 0, 2, 2, 2, 2, 3, 3, 4, 0};\n static const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};\n static const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};\n static const int shiftc[] = {0, 18, 12, 6, 0};\n static const int shifte[] = {0, 6, 4, 2, 0};\n\n auto s = reinterpret_cast(buf);\n int len = lengths[s[0] >> 3];\n\n // Compute the pointer to the next character early so that the next\n // iteration can start working on the next character. Neither Clang\n // nor GCC figure out this reordering on their own.\n const char* next = buf + len + !len;\n\n // Assume a four-byte character and load four bytes. Unused bits are\n // shifted out.\n *c = uint32_t(s[0] & masks[len]) << 18;\n *c |= uint32_t(s[1] & 0x3f) << 12;\n *c |= uint32_t(s[2] & 0x3f) << 6;\n *c |= uint32_t(s[3] & 0x3f) << 0;\n *c >>= shiftc[len];\n\n // Accumulate the various error conditions.\n *e = (*c < mins[len]) << 6; // non-canonical encoding\n *e |= ((*c >> 11) == 0x1b) << 7; // surrogate half?\n *e |= (*c > 0x10FFFF) << 8; // out of range?\n *e |= (s[1] & 0xc0) >> 2;\n *e |= (s[2] & 0xc0) >> 4;\n *e |= (s[3]) >> 6;\n *e ^= 0x2a; // top two bits of each tail byte correct?\n *e >>= shifte[len];\n\n return next;\n}\n} // namespace internal\n\ntemplate <> struct formatter {\n format_parse_context::iterator parse(format_parse_context& ctx) {\n return ctx.begin();\n }\n\n format_context::iterator format(const internal::bigint& n,\n format_context& ctx) {\n auto out = ctx.out();\n bool first = true;\n for (auto i = n.bigits_.size(); i > 0; --i) {\n auto value = n.bigits_[i - 1u];\n if (first) {\n out = format_to(out, \"{:x}\", value);\n first = false;\n continue;\n }\n out = format_to(out, \"{:08x}\", value);\n }\n if (n.exp_ > 0)\n out = format_to(out, \"p{}\", n.exp_ * internal::bigint::bigit_bits);\n return out;\n }\n};\n\nFMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {\n auto transcode = [this](const char* p) {\n auto cp = uint32_t();\n auto error = 0;\n p = utf8_decode(p, &cp, &error);\n if (error != 0) FMT_THROW(std::runtime_error(\"invalid utf8\"));\n if (cp <= 0xFFFF) {\n buffer_.push_back(static_cast(cp));\n } else {\n cp -= 0x10000;\n buffer_.push_back(static_cast(0xD800 + (cp >> 10)));\n buffer_.push_back(static_cast(0xDC00 + (cp & 0x3FF)));\n }\n return p;\n };\n auto p = s.data();\n const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars.\n if (s.size() >= block_size) {\n for (auto end = p + s.size() - block_size + 1; p < end;) p = transcode(p);\n }\n if (auto num_chars_left = s.data() + s.size() - p) {\n char buf[2 * block_size - 1] = {};\n memcpy(buf, p, to_unsigned(num_chars_left));\n p = buf;\n do {\n p = transcode(p);\n } while (p - buf < num_chars_left);\n }\n buffer_.push_back(0);\n}\n\nFMT_FUNC void format_system_error(internal::buffer& out, int error_code,\n string_view message) FMT_NOEXCEPT {\n FMT_TRY {\n memory_buffer buf;\n buf.resize(inline_buffer_size);\n for (;;) {\n char* system_message = &buf[0];\n int result =\n internal::safe_strerror(error_code, system_message, buf.size());\n if (result == 0) {\n internal::writer w(out);\n w.write(message);\n w.write(\": \");\n w.write(system_message);\n return;\n }\n if (result != ERANGE)\n break; // Can't get error message, report error code instead.\n buf.resize(buf.size() * 2);\n }\n }\n FMT_CATCH(...) {}\n format_error_code(out, error_code, message);\n}\n\nFMT_FUNC void internal::error_handler::on_error(const char* message) {\n FMT_THROW(format_error(message));\n}\n\nFMT_FUNC void report_system_error(int error_code,\n fmt::string_view message) FMT_NOEXCEPT {\n report_error(format_system_error, error_code, message);\n}\n\nFMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {\n memory_buffer buffer;\n internal::vformat_to(buffer, format_str,\n basic_format_args>(args));\n#ifdef _WIN32\n auto fd = _fileno(f);\n if (_isatty(fd)) {\n internal::utf8_to_utf16 u16(string_view(buffer.data(), buffer.size()));\n auto written = DWORD();\n if (!WriteConsoleW(reinterpret_cast(_get_osfhandle(fd)),\n u16.c_str(), static_cast(u16.size()), &written,\n nullptr)) {\n FMT_THROW(format_error(\"failed to write to console\"));\n }\n return;\n }\n#endif\n internal::fwrite_fully(buffer.data(), 1, buffer.size(), f);\n}\n\n#ifdef _WIN32\n// Print assuming legacy (non-Unicode) encoding.\nFMT_FUNC void internal::vprint_mojibake(std::FILE* f, string_view format_str,\n format_args args) {\n memory_buffer buffer;\n internal::vformat_to(buffer, format_str,\n basic_format_args>(args));\n fwrite_fully(buffer.data(), 1, buffer.size(), f);\n}\n#endif\n\nFMT_FUNC void vprint(string_view format_str, format_args args) {\n vprint(stdout, format_str, args);\n}\n\nFMT_END_NAMESPACE\n\n#ifdef _MSC_VER\n# pragma warning(pop)\n#endif\n\n#endif // FMT_FORMAT_INL_H_\n" }, { "path": "examples/lesson04/fig04_12/fmt/format.h", "content": "/*\n Formatting library for C++\n\n Copyright (c) 2012 - present, Victor Zverovich\n\n Permission is hereby granted, free of charge, to any person obtaining\n a copy of this software and associated documentation files (the\n \"Software\"), to deal in the Software without restriction, including\n without limitation the rights to use, copy, modify, merge, publish,\n distribute, sublicense, and/or sell copies of the Software, and to\n permit persons to whom the Software is furnished to do so, subject to\n the following conditions:\n\n The above copyright notice and this permission notice shall be\n included in all copies or substantial portions of the Software.\n\n THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\n EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\n NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\n LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n --- Optional exception to the license ---\n\n As an exception, if, as a result of your compiling your source code, portions\n of this Software are embedded into a machine-executable object form of such\n source code, you may redistribute such embedded portions in such object form\n without including the above copyright and permission notices.\n */\n\n#ifndef FMT_FORMAT_H_\n#define FMT_FORMAT_H_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"core.h\"\n\n#ifdef FMT_DEPRECATED_INCLUDE_OS\n# include \"os.h\"\n#endif\n\n#ifdef __INTEL_COMPILER\n# define FMT_ICC_VERSION __INTEL_COMPILER\n#elif defined(__ICL)\n# define FMT_ICC_VERSION __ICL\n#else\n# define FMT_ICC_VERSION 0\n#endif\n\n#ifdef __NVCC__\n# define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)\n#else\n# define FMT_CUDA_VERSION 0\n#endif\n\n#ifdef __has_builtin\n# define FMT_HAS_BUILTIN(x) __has_builtin(x)\n#else\n# define FMT_HAS_BUILTIN(x) 0\n#endif\n\n#if FMT_GCC_VERSION || FMT_CLANG_VERSION\n# define FMT_NOINLINE __attribute__((noinline))\n#else\n# define FMT_NOINLINE\n#endif\n\n#if __cplusplus == 201103L || __cplusplus == 201402L\n# if defined(__clang__)\n# define FMT_FALLTHROUGH [[clang::fallthrough]]\n# elif FMT_GCC_VERSION >= 700 && !defined(__PGI)\n# define FMT_FALLTHROUGH [[gnu::fallthrough]]\n# else\n# define FMT_FALLTHROUGH\n# endif\n#elif FMT_HAS_CPP17_ATTRIBUTE(fallthrough) || \\\n (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)\n# define FMT_FALLTHROUGH [[fallthrough]]\n#else\n# define FMT_FALLTHROUGH\n#endif\n\n#ifndef FMT_THROW\n# if FMT_EXCEPTIONS\n# if FMT_MSC_VER || FMT_NVCC\nFMT_BEGIN_NAMESPACE\nnamespace internal {\ntemplate inline void do_throw(const Exception& x) {\n // Silence unreachable code warnings in MSVC and NVCC because these\n // are nearly impossible to fix in a generic code.\n volatile bool b = true;\n if (b) throw x;\n}\n} // namespace internal\nFMT_END_NAMESPACE\n# define FMT_THROW(x) internal::do_throw(x)\n# else\n# define FMT_THROW(x) throw x\n# endif\n# else\n# define FMT_THROW(x) \\\n do { \\\n static_cast(sizeof(x)); \\\n FMT_ASSERT(false, \"\"); \\\n } while (false)\n# endif\n#endif\n\n#if FMT_EXCEPTIONS\n# define FMT_TRY try\n# define FMT_CATCH(x) catch (x)\n#else\n# define FMT_TRY if (true)\n# define FMT_CATCH(x) if (false)\n#endif\n\n#ifndef FMT_USE_USER_DEFINED_LITERALS\n// For Intel and NVIDIA compilers both they and the system gcc/msc support UDLs.\n# if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \\\n FMT_MSC_VER >= 1900) && \\\n (!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || \\\n FMT_CUDA_VERSION >= 700)\n# define FMT_USE_USER_DEFINED_LITERALS 1\n# else\n# define FMT_USE_USER_DEFINED_LITERALS 0\n# endif\n#endif\n\n#ifndef FMT_USE_UDL_TEMPLATE\n// EDG front end based compilers (icc, nvcc) and GCC < 6.4 do not propertly\n// support UDL templates and GCC >= 9 warns about them.\n# if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && \\\n FMT_CUDA_VERSION == 0 && \\\n ((FMT_GCC_VERSION >= 604 && FMT_GCC_VERSION <= 900 && \\\n __cplusplus >= 201402L) || \\\n FMT_CLANG_VERSION >= 304)\n# define FMT_USE_UDL_TEMPLATE 1\n# else\n# define FMT_USE_UDL_TEMPLATE 0\n# endif\n#endif\n\n#ifndef FMT_USE_FLOAT\n# define FMT_USE_FLOAT 1\n#endif\n\n#ifndef FMT_USE_DOUBLE\n# define FMT_USE_DOUBLE 1\n#endif\n\n#ifndef FMT_USE_LONG_DOUBLE\n# define FMT_USE_LONG_DOUBLE 1\n#endif\n\n// __builtin_clz is broken in clang with Microsoft CodeGen:\n// https://github.com/fmtlib/fmt/issues/519\n#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER\n# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)\n#endif\n#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER\n# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)\n#endif\n\n// Some compilers masquerade as both MSVC and GCC-likes or otherwise support\n// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the\n// MSVC intrinsics if the clz and clzll builtins are not available.\n#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED)\n# include // _BitScanReverse, _BitScanReverse64\n\nFMT_BEGIN_NAMESPACE\nnamespace internal {\n// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.\n# ifndef __clang__\n# pragma intrinsic(_BitScanReverse)\n# endif\ninline uint32_t clz(uint32_t x) {\n unsigned long r = 0;\n _BitScanReverse(&r, x);\n\n FMT_ASSERT(x != 0, \"\");\n // Static analysis complains about using uninitialized data\n // \"r\", but the only way that can happen is if \"x\" is 0,\n // which the callers guarantee to not happen.\n# pragma warning(suppress : 6102)\n return 31 - r;\n}\n# define FMT_BUILTIN_CLZ(n) internal::clz(n)\n\n# if defined(_WIN64) && !defined(__clang__)\n# pragma intrinsic(_BitScanReverse64)\n# endif\n\ninline uint32_t clzll(uint64_t x) {\n unsigned long r = 0;\n# ifdef _WIN64\n _BitScanReverse64(&r, x);\n# else\n // Scan the high 32 bits.\n if (_BitScanReverse(&r, static_cast(x >> 32))) return 63 - (r + 32);\n\n // Scan the low 32 bits.\n _BitScanReverse(&r, static_cast(x));\n# endif\n\n FMT_ASSERT(x != 0, \"\");\n // Static analysis complains about using uninitialized data\n // \"r\", but the only way that can happen is if \"x\" is 0,\n // which the callers guarantee to not happen.\n# pragma warning(suppress : 6102)\n return 63 - r;\n}\n# define FMT_BUILTIN_CLZLL(n) internal::clzll(n)\n} // namespace internal\nFMT_END_NAMESPACE\n#endif\n\n// Enable the deprecated numeric alignment.\n#ifndef FMT_NUMERIC_ALIGN\n# define FMT_NUMERIC_ALIGN 1\n#endif\n\n// Enable the deprecated percent specifier.\n#ifndef FMT_DEPRECATED_PERCENT\n# define FMT_DEPRECATED_PERCENT 0\n#endif\n\nFMT_BEGIN_NAMESPACE\nnamespace internal {\n\n// An equivalent of `*reinterpret_cast(&source)` that doesn't have\n// undefined behavior (e.g. due to type aliasing).\n// Example: uint64_t d = bit_cast(2.718);\ntemplate \ninline Dest bit_cast(const Source& source) {\n static_assert(sizeof(Dest) == sizeof(Source), \"size mismatch\");\n Dest dest;\n std::memcpy(&dest, &source, sizeof(dest));\n return dest;\n}\n\ninline bool is_big_endian() {\n const auto u = 1u;\n struct bytes {\n char data[sizeof(u)];\n };\n return bit_cast(u).data[0] == 0;\n}\n\n// A fallback implementation of uintptr_t for systems that lack it.\nstruct fallback_uintptr {\n unsigned char value[sizeof(void*)];\n\n fallback_uintptr() = default;\n explicit fallback_uintptr(const void* p) {\n *this = bit_cast(p);\n if (is_big_endian()) {\n for (size_t i = 0, j = sizeof(void*) - 1; i < j; ++i, --j)\n std::swap(value[i], value[j]);\n }\n }\n};\n#ifdef UINTPTR_MAX\nusing uintptr_t = ::uintptr_t;\ninline uintptr_t to_uintptr(const void* p) { return bit_cast(p); }\n#else\nusing uintptr_t = fallback_uintptr;\ninline fallback_uintptr to_uintptr(const void* p) {\n return fallback_uintptr(p);\n}\n#endif\n\n// Returns the largest possible value for type T. Same as\n// std::numeric_limits::max() but shorter and not affected by the max macro.\ntemplate constexpr T max_value() {\n return (std::numeric_limits::max)();\n}\ntemplate constexpr int num_bits() {\n return std::numeric_limits::digits;\n}\ntemplate <> constexpr int num_bits() {\n return static_cast(sizeof(void*) *\n std::numeric_limits::digits);\n}\n\n// An approximation of iterator_t for pre-C++20 systems.\ntemplate \nusing iterator_t = decltype(std::begin(std::declval()));\n\n// Detect the iterator category of *any* given type in a SFINAE-friendly way.\n// Unfortunately, older implementations of std::iterator_traits are not safe\n// for use in a SFINAE-context.\ntemplate \nstruct iterator_category : std::false_type {};\n\ntemplate struct iterator_category {\n using type = std::random_access_iterator_tag;\n};\n\ntemplate \nstruct iterator_category> {\n using type = typename It::iterator_category;\n};\n\n// Detect if *any* given type models the OutputIterator concept.\ntemplate class is_output_iterator {\n // Check for mutability because all iterator categories derived from\n // std::input_iterator_tag *may* also meet the requirements of an\n // OutputIterator, thereby falling into the category of 'mutable iterators'\n // [iterator.requirements.general] clause 4. The compiler reveals this\n // property only at the point of *actually dereferencing* the iterator!\n template \n static decltype(*(std::declval())) test(std::input_iterator_tag);\n template static char& test(std::output_iterator_tag);\n template static const char& test(...);\n\n using type = decltype(test(typename iterator_category::type{}));\n\n public:\n enum { value = !std::is_const>::value };\n};\n\n// A workaround for std::string not having mutable data() until C++17.\ntemplate inline Char* get_data(std::basic_string& s) {\n return &s[0];\n}\ntemplate \ninline typename Container::value_type* get_data(Container& c) {\n return c.data();\n}\n\n#if defined(_SECURE_SCL) && _SECURE_SCL\n// Make a checked iterator to avoid MSVC warnings.\ntemplate using checked_ptr = stdext::checked_array_iterator;\ntemplate checked_ptr make_checked(T* p, std::size_t size) {\n return {p, size};\n}\n#else\ntemplate using checked_ptr = T*;\ntemplate inline T* make_checked(T* p, std::size_t) { return p; }\n#endif\n\ntemplate ::value)>\ninline checked_ptr reserve(\n std::back_insert_iterator& it, std::size_t n) {\n Container& c = get_container(it);\n std::size_t size = c.size();\n c.resize(size + n);\n return make_checked(get_data(c) + size, n);\n}\n\ntemplate \ninline Iterator& reserve(Iterator& it, std::size_t) {\n return it;\n}\n\n// An output iterator that counts the number of objects written to it and\n// discards them.\nclass counting_iterator {\n private:\n std::size_t count_;\n\n public:\n using iterator_category = std::output_iterator_tag;\n using difference_type = std::ptrdiff_t;\n using pointer = void;\n using reference = void;\n using _Unchecked_type = counting_iterator; // Mark iterator as checked.\n\n struct value_type {\n template void operator=(const T&) {}\n };\n\n counting_iterator() : count_(0) {}\n\n std::size_t count() const { return count_; }\n\n counting_iterator& operator++() {\n ++count_;\n return *this;\n }\n\n counting_iterator operator++(int) {\n auto it = *this;\n ++*this;\n return it;\n }\n\n value_type operator*() const { return {}; }\n};\n\ntemplate class truncating_iterator_base {\n protected:\n OutputIt out_;\n std::size_t limit_;\n std::size_t count_;\n\n truncating_iterator_base(OutputIt out, std::size_t limit)\n : out_(out), limit_(limit), count_(0) {}\n\n public:\n using iterator_category = std::output_iterator_tag;\n using value_type = typename std::iterator_traits::value_type;\n using difference_type = void;\n using pointer = void;\n using reference = void;\n using _Unchecked_type =\n truncating_iterator_base; // Mark iterator as checked.\n\n OutputIt base() const { return out_; }\n std::size_t count() const { return count_; }\n};\n\n// An output iterator that truncates the output and counts the number of objects\n// written to it.\ntemplate ::value_type>::type>\nclass truncating_iterator;\n\ntemplate \nclass truncating_iterator\n : public truncating_iterator_base {\n mutable typename truncating_iterator_base::value_type blackhole_;\n\n public:\n using value_type = typename truncating_iterator_base::value_type;\n\n truncating_iterator(OutputIt out, std::size_t limit)\n : truncating_iterator_base(out, limit) {}\n\n truncating_iterator& operator++() {\n if (this->count_++ < this->limit_) ++this->out_;\n return *this;\n }\n\n truncating_iterator operator++(int) {\n auto it = *this;\n ++*this;\n return it;\n }\n\n value_type& operator*() const {\n return this->count_ < this->limit_ ? *this->out_ : blackhole_;\n }\n};\n\ntemplate \nclass truncating_iterator\n : public truncating_iterator_base {\n public:\n truncating_iterator(OutputIt out, std::size_t limit)\n : truncating_iterator_base(out, limit) {}\n\n template truncating_iterator& operator=(T val) {\n if (this->count_++ < this->limit_) *this->out_++ = val;\n return *this;\n }\n\n truncating_iterator& operator++() { return *this; }\n truncating_iterator& operator++(int) { return *this; }\n truncating_iterator& operator*() { return *this; }\n};\n\n// A range with the specified output iterator and value type.\ntemplate \nclass output_range {\n private:\n OutputIt it_;\n\n public:\n using value_type = T;\n using iterator = OutputIt;\n struct sentinel {};\n\n explicit output_range(OutputIt it) : it_(it) {}\n OutputIt begin() const { return it_; }\n sentinel end() const { return {}; } // Sentinel is not used yet.\n};\n\ntemplate \ninline size_t count_code_points(basic_string_view s) {\n return s.size();\n}\n\n// Counts the number of code points in a UTF-8 string.\ninline size_t count_code_points(basic_string_view s) {\n const char* data = s.data();\n size_t num_code_points = 0;\n for (size_t i = 0, size = s.size(); i != size; ++i) {\n if ((data[i] & 0xc0) != 0x80) ++num_code_points;\n }\n return num_code_points;\n}\n\ninline size_t count_code_points(basic_string_view s) {\n return count_code_points(basic_string_view(\n reinterpret_cast(s.data()), s.size()));\n}\n\ntemplate \ninline size_t code_point_index(basic_string_view s, size_t n) {\n size_t size = s.size();\n return n < size ? n : size;\n}\n\n// Calculates the index of the nth code point in a UTF-8 string.\ninline size_t code_point_index(basic_string_view s, size_t n) {\n const char8_type* data = s.data();\n size_t num_code_points = 0;\n for (size_t i = 0, size = s.size(); i != size; ++i) {\n if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) {\n return i;\n }\n }\n return s.size();\n}\n\ninline char8_type to_char8_t(char c) { return static_cast(c); }\n\ntemplate \nusing needs_conversion = bool_constant<\n std::is_same::value_type,\n char>::value &&\n std::is_same::value>;\n\ntemplate ::value)>\nOutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {\n return std::copy(begin, end, it);\n}\n\ntemplate ::value)>\nOutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {\n return std::transform(begin, end, it, to_char8_t);\n}\n\n#ifndef FMT_USE_GRISU\n# define FMT_USE_GRISU 1\n#endif\n\ntemplate constexpr bool use_grisu() {\n return FMT_USE_GRISU && std::numeric_limits::is_iec559 &&\n sizeof(T) <= sizeof(double);\n}\n\ntemplate \ntemplate \nvoid buffer::append(const U* begin, const U* end) {\n std::size_t new_size = size_ + to_unsigned(end - begin);\n reserve(new_size);\n std::uninitialized_copy(begin, end, make_checked(ptr_, capacity_) + size_);\n size_ = new_size;\n}\n} // namespace internal\n\n// A range with an iterator appending to a buffer.\ntemplate \nclass buffer_range : public internal::output_range<\n std::back_insert_iterator>, T> {\n public:\n using iterator = std::back_insert_iterator>;\n using internal::output_range::output_range;\n buffer_range(internal::buffer& buf)\n : internal::output_range(std::back_inserter(buf)) {}\n};\n\nclass FMT_DEPRECATED u8string_view\n : public basic_string_view {\n public:\n u8string_view(const char* s)\n : basic_string_view(\n reinterpret_cast(s)) {}\n u8string_view(const char* s, size_t count) FMT_NOEXCEPT\n : basic_string_view(\n reinterpret_cast(s), count) {}\n};\n\n#if FMT_USE_USER_DEFINED_LITERALS\ninline namespace literals {\nFMT_DEPRECATED inline basic_string_view operator\"\" _u(\n const char* s, std::size_t n) {\n return {reinterpret_cast(s), n};\n}\n} // namespace literals\n#endif\n\n// The number of characters to store in the basic_memory_buffer object itself\n// to avoid dynamic memory allocation.\nenum { inline_buffer_size = 500 };\n\n/**\n \\rst\n A dynamically growing memory buffer for trivially copyable/constructible types\n with the first ``SIZE`` elements stored in the object itself.\n\n You can use one of the following type aliases for common character types:\n\n +----------------+------------------------------+\n | Type | Definition |\n +================+==============================+\n | memory_buffer | basic_memory_buffer |\n +----------------+------------------------------+\n | wmemory_buffer | basic_memory_buffer |\n +----------------+------------------------------+\n\n **Example**::\n\n fmt::memory_buffer out;\n format_to(out, \"The answer is {}.\", 42);\n\n This will append the following output to the ``out`` object:\n\n .. code-block:: none\n\n The answer is 42.\n\n The output can be converted to an ``std::string`` with ``to_string(out)``.\n \\endrst\n */\ntemplate >\nclass basic_memory_buffer : private Allocator, public internal::buffer {\n private:\n T store_[SIZE];\n\n // Deallocate memory allocated by the buffer.\n void deallocate() {\n T* data = this->data();\n if (data != store_) Allocator::deallocate(data, this->capacity());\n }\n\n protected:\n void grow(std::size_t size) FMT_OVERRIDE;\n\n public:\n using value_type = T;\n using const_reference = const T&;\n\n explicit basic_memory_buffer(const Allocator& alloc = Allocator())\n : Allocator(alloc) {\n this->set(store_, SIZE);\n }\n ~basic_memory_buffer() FMT_OVERRIDE { deallocate(); }\n\n private:\n // Move data from other to this buffer.\n void move(basic_memory_buffer& other) {\n Allocator &this_alloc = *this, &other_alloc = other;\n this_alloc = std::move(other_alloc);\n T* data = other.data();\n std::size_t size = other.size(), capacity = other.capacity();\n if (data == other.store_) {\n this->set(store_, capacity);\n std::uninitialized_copy(other.store_, other.store_ + size,\n internal::make_checked(store_, capacity));\n } else {\n this->set(data, capacity);\n // Set pointer to the inline array so that delete is not called\n // when deallocating.\n other.set(other.store_, 0);\n }\n this->resize(size);\n }\n\n public:\n /**\n \\rst\n Constructs a :class:`fmt::basic_memory_buffer` object moving the content\n of the other object to it.\n \\endrst\n */\n basic_memory_buffer(basic_memory_buffer&& other) FMT_NOEXCEPT { move(other); }\n\n /**\n \\rst\n Moves the content of the other ``basic_memory_buffer`` object to this one.\n \\endrst\n */\n basic_memory_buffer& operator=(basic_memory_buffer&& other) FMT_NOEXCEPT {\n FMT_ASSERT(this != &other, \"\");\n deallocate();\n move(other);\n return *this;\n }\n\n // Returns a copy of the allocator associated with this buffer.\n Allocator get_allocator() const { return *this; }\n};\n\ntemplate \nvoid basic_memory_buffer::grow(std::size_t size) {\n#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION\n if (size > 1000) throw std::runtime_error(\"fuzz mode - won't grow that much\");\n#endif\n std::size_t old_capacity = this->capacity();\n std::size_t new_capacity = old_capacity + old_capacity / 2;\n if (size > new_capacity) new_capacity = size;\n T* old_data = this->data();\n T* new_data = std::allocator_traits::allocate(*this, new_capacity);\n // The following code doesn't throw, so the raw pointer above doesn't leak.\n std::uninitialized_copy(old_data, old_data + this->size(),\n internal::make_checked(new_data, new_capacity));\n this->set(new_data, new_capacity);\n // deallocate must not throw according to the standard, but even if it does,\n // the buffer already uses the new storage and will deallocate it in\n // destructor.\n if (old_data != store_) Allocator::deallocate(old_data, old_capacity);\n}\n\nusing memory_buffer = basic_memory_buffer;\nusing wmemory_buffer = basic_memory_buffer;\n\n/** A formatting error such as invalid format string. */\nFMT_CLASS_API\nclass FMT_API format_error : public std::runtime_error {\n public:\n explicit format_error(const char* message) : std::runtime_error(message) {}\n explicit format_error(const std::string& message)\n : std::runtime_error(message) {}\n format_error(const format_error&) = default;\n format_error& operator=(const format_error&) = default;\n format_error(format_error&&) = default;\n format_error& operator=(format_error&&) = default;\n ~format_error() FMT_NOEXCEPT FMT_OVERRIDE;\n};\n\nnamespace internal {\n\n// Returns true if value is negative, false otherwise.\n// Same as `value < 0` but doesn't produce warnings if T is an unsigned type.\ntemplate ::is_signed)>\nFMT_CONSTEXPR bool is_negative(T value) {\n return value < 0;\n}\ntemplate ::is_signed)>\nFMT_CONSTEXPR bool is_negative(T) {\n return false;\n}\n\ntemplate ::value)>\nFMT_CONSTEXPR bool is_supported_floating_point(T) {\n return (std::is_same::value && FMT_USE_FLOAT) ||\n (std::is_same::value && FMT_USE_DOUBLE) ||\n (std::is_same::value && FMT_USE_LONG_DOUBLE);\n}\n\n// Smallest of uint32_t, uint64_t, uint128_t that is large enough to\n// represent all values of T.\ntemplate \nusing uint32_or_64_or_128_t = conditional_t<\n std::numeric_limits::digits <= 32, uint32_t,\n conditional_t::digits <= 64, uint64_t, uint128_t>>;\n\n// Static data is placed in this class template for the header-only config.\ntemplate struct FMT_EXTERN_TEMPLATE_API basic_data {\n static const uint64_t powers_of_10_64[];\n static const uint32_t zero_or_powers_of_10_32[];\n static const uint64_t zero_or_powers_of_10_64[];\n static const uint64_t pow10_significands[];\n static const int16_t pow10_exponents[];\n static const char digits[];\n static const char hex_digits[];\n static const char foreground_color[];\n static const char background_color[];\n static const char reset_color[5];\n static const wchar_t wreset_color[5];\n static const char signs[];\n};\n\nFMT_EXTERN template struct basic_data;\n\n// This is a struct rather than an alias to avoid shadowing warnings in gcc.\nstruct data : basic_data<> {};\n\n#ifdef FMT_BUILTIN_CLZLL\n// Returns the number of decimal digits in n. Leading zeros are not counted\n// except for n == 0 in which case count_digits returns 1.\ninline int count_digits(uint64_t n) {\n // Based on http://graphics.stanford.edu/~seander/bithacks.html#IntegerLog10\n // and the benchmark https://github.com/localvoid/cxx-benchmark-count-digits.\n int t = (64 - FMT_BUILTIN_CLZLL(n | 1)) * 1233 >> 12;\n return t - (n < data::zero_or_powers_of_10_64[t]) + 1;\n}\n#else\n// Fallback version of count_digits used when __builtin_clz is not available.\ninline int count_digits(uint64_t n) {\n int count = 1;\n for (;;) {\n // Integer division is slow so do it for a group of four digits instead\n // of for every digit. The idea comes from the talk by Alexandrescu\n // \"Three Optimization Tips for C++\". See speed-test for a comparison.\n if (n < 10) return count;\n if (n < 100) return count + 1;\n if (n < 1000) return count + 2;\n if (n < 10000) return count + 3;\n n /= 10000u;\n count += 4;\n }\n}\n#endif\n\n#if FMT_USE_INT128\ninline int count_digits(uint128_t n) {\n int count = 1;\n for (;;) {\n // Integer division is slow so do it for a group of four digits instead\n // of for every digit. The idea comes from the talk by Alexandrescu\n // \"Three Optimization Tips for C++\". See speed-test for a comparison.\n if (n < 10) return count;\n if (n < 100) return count + 1;\n if (n < 1000) return count + 2;\n if (n < 10000) return count + 3;\n n /= 10000U;\n count += 4;\n }\n}\n#endif\n\n// Counts the number of digits in n. BITS = log2(radix).\ntemplate inline int count_digits(UInt n) {\n int num_digits = 0;\n do {\n ++num_digits;\n } while ((n >>= BITS) != 0);\n return num_digits;\n}\n\ntemplate <> int count_digits<4>(internal::fallback_uintptr n);\n\n#if FMT_GCC_VERSION || FMT_CLANG_VERSION\n# define FMT_ALWAYS_INLINE inline __attribute__((always_inline))\n#else\n# define FMT_ALWAYS_INLINE\n#endif\n\n#ifdef FMT_BUILTIN_CLZ\n// Optional version of count_digits for better performance on 32-bit platforms.\ninline int count_digits(uint32_t n) {\n int t = (32 - FMT_BUILTIN_CLZ(n | 1)) * 1233 >> 12;\n return t - (n < data::zero_or_powers_of_10_32[t]) + 1;\n}\n#endif\n\ntemplate FMT_API std::string grouping_impl(locale_ref loc);\ntemplate inline std::string grouping(locale_ref loc) {\n return grouping_impl(loc);\n}\ntemplate <> inline std::string grouping(locale_ref loc) {\n return grouping_impl(loc);\n}\n\ntemplate FMT_API Char thousands_sep_impl(locale_ref loc);\ntemplate inline Char thousands_sep(locale_ref loc) {\n return Char(thousands_sep_impl(loc));\n}\ntemplate <> inline wchar_t thousands_sep(locale_ref loc) {\n return thousands_sep_impl(loc);\n}\n\ntemplate FMT_API Char decimal_point_impl(locale_ref loc);\ntemplate inline Char decimal_point(locale_ref loc) {\n return Char(decimal_point_impl(loc));\n}\ntemplate <> inline wchar_t decimal_point(locale_ref loc) {\n return decimal_point_impl(loc);\n}\n\n// Formats a decimal unsigned integer value writing into buffer.\n// add_thousands_sep is called after writing each char to add a thousands\n// separator if necessary.\ntemplate \ninline Char* format_decimal(Char* buffer, UInt value, int num_digits,\n F add_thousands_sep) {\n FMT_ASSERT(num_digits >= 0, \"invalid digit count\");\n buffer += num_digits;\n Char* end = buffer;\n while (value >= 100) {\n // Integer division is slow so do it for a group of two digits instead\n // of for every digit. The idea comes from the talk by Alexandrescu\n // \"Three Optimization Tips for C++\". See speed-test for a comparison.\n auto index = static_cast((value % 100) * 2);\n value /= 100;\n *--buffer = static_cast(data::digits[index + 1]);\n add_thousands_sep(buffer);\n *--buffer = static_cast(data::digits[index]);\n add_thousands_sep(buffer);\n }\n if (value < 10) {\n *--buffer = static_cast('0' + value);\n return end;\n }\n auto index = static_cast(value * 2);\n *--buffer = static_cast(data::digits[index + 1]);\n add_thousands_sep(buffer);\n *--buffer = static_cast(data::digits[index]);\n return end;\n}\n\ntemplate constexpr int digits10() FMT_NOEXCEPT {\n return std::numeric_limits::digits10;\n}\ntemplate <> constexpr int digits10() FMT_NOEXCEPT { return 38; }\ntemplate <> constexpr int digits10() FMT_NOEXCEPT { return 38; }\n\ntemplate \ninline Iterator format_decimal(Iterator out, UInt value, int num_digits,\n F add_thousands_sep) {\n FMT_ASSERT(num_digits >= 0, \"invalid digit count\");\n // Buffer should be large enough to hold all digits (<= digits10 + 1).\n enum { max_size = digits10() + 1 };\n Char buffer[2 * max_size];\n auto end = format_decimal(buffer, value, num_digits, add_thousands_sep);\n return internal::copy_str(buffer, end, out);\n}\n\ntemplate \ninline It format_decimal(It out, UInt value, int num_digits) {\n return format_decimal(out, value, num_digits, [](Char*) {});\n}\n\ntemplate \ninline Char* format_uint(Char* buffer, UInt value, int num_digits,\n bool upper = false) {\n buffer += num_digits;\n Char* end = buffer;\n do {\n const char* digits = upper ? \"0123456789ABCDEF\" : data::hex_digits;\n unsigned digit = (value & ((1 << BASE_BITS) - 1));\n *--buffer = static_cast(BASE_BITS < 4 ? static_cast('0' + digit)\n : digits[digit]);\n } while ((value >>= BASE_BITS) != 0);\n return end;\n}\n\ntemplate \nChar* format_uint(Char* buffer, internal::fallback_uintptr n, int num_digits,\n bool = false) {\n auto char_digits = std::numeric_limits::digits / 4;\n int start = (num_digits + char_digits - 1) / char_digits - 1;\n if (int start_digits = num_digits % char_digits) {\n unsigned value = n.value[start--];\n buffer = format_uint(buffer, value, start_digits);\n }\n for (; start >= 0; --start) {\n unsigned value = n.value[start];\n buffer += char_digits;\n auto p = buffer;\n for (int i = 0; i < char_digits; ++i) {\n unsigned digit = (value & ((1 << BASE_BITS) - 1));\n *--p = static_cast(data::hex_digits[digit]);\n value >>= BASE_BITS;\n }\n }\n return buffer;\n}\n\ntemplate \ninline It format_uint(It out, UInt value, int num_digits, bool upper = false) {\n // Buffer should be large enough to hold all digits (digits / BASE_BITS + 1).\n char buffer[num_bits() / BASE_BITS + 1];\n format_uint(buffer, value, num_digits, upper);\n return internal::copy_str(buffer, buffer + num_digits, out);\n}\n\n// A converter from UTF-8 to UTF-16.\nclass utf8_to_utf16 {\n private:\n wmemory_buffer buffer_;\n\n public:\n FMT_API explicit utf8_to_utf16(string_view s);\n operator wstring_view() const { return {&buffer_[0], size()}; }\n size_t size() const { return buffer_.size() - 1; }\n const wchar_t* c_str() const { return &buffer_[0]; }\n std::wstring str() const { return {&buffer_[0], size()}; }\n};\n\ntemplate struct null {};\n\n// Workaround an array initialization issue in gcc 4.8.\ntemplate struct fill_t {\n private:\n enum { max_size = 4 };\n Char data_[max_size];\n unsigned char size_;\n\n public:\n FMT_CONSTEXPR void operator=(basic_string_view s) {\n auto size = s.size();\n if (size > max_size) {\n FMT_THROW(format_error(\"invalid fill\"));\n return;\n }\n for (size_t i = 0; i < size; ++i) data_[i] = s[i];\n size_ = static_cast(size);\n }\n\n size_t size() const { return size_; }\n const Char* data() const { return data_; }\n\n FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; }\n FMT_CONSTEXPR const Char& operator[](size_t index) const {\n return data_[index];\n }\n\n static FMT_CONSTEXPR fill_t make() {\n auto fill = fill_t();\n fill[0] = Char(' ');\n fill.size_ = 1;\n return fill;\n }\n};\n} // namespace internal\n\n// We cannot use enum classes as bit fields because of a gcc bug\n// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=61414.\nnamespace align {\nenum type { none, left, right, center, numeric };\n}\nusing align_t = align::type;\n\nnamespace sign {\nenum type { none, minus, plus, space };\n}\nusing sign_t = sign::type;\n\n// Format specifiers for built-in and string types.\ntemplate struct basic_format_specs {\n int width;\n int precision;\n char type;\n align_t align : 4;\n sign_t sign : 3;\n bool alt : 1; // Alternate form ('#').\n internal::fill_t fill;\n\n constexpr basic_format_specs()\n : width(0),\n precision(-1),\n type(0),\n align(align::none),\n sign(sign::none),\n alt(false),\n fill(internal::fill_t::make()) {}\n};\n\nusing format_specs = basic_format_specs;\n\nnamespace internal {\n\n// A floating-point presentation format.\nenum class float_format : unsigned char {\n general, // General: exponent notation or fixed point based on magnitude.\n exp, // Exponent notation with the default precision of 6, e.g. 1.2e-3.\n fixed, // Fixed point with the default precision of 6, e.g. 0.0012.\n hex\n};\n\nstruct float_specs {\n int precision;\n float_format format : 8;\n sign_t sign : 8;\n bool upper : 1;\n bool locale : 1;\n bool percent : 1;\n bool binary32 : 1;\n bool use_grisu : 1;\n bool showpoint : 1;\n};\n\n// Writes the exponent exp in the form \"[+-]d{2,3}\" to buffer.\ntemplate It write_exponent(int exp, It it) {\n FMT_ASSERT(-10000 < exp && exp < 10000, \"exponent out of range\");\n if (exp < 0) {\n *it++ = static_cast('-');\n exp = -exp;\n } else {\n *it++ = static_cast('+');\n }\n if (exp >= 100) {\n const char* top = data::digits + (exp / 100) * 2;\n if (exp >= 1000) *it++ = static_cast(top[0]);\n *it++ = static_cast(top[1]);\n exp %= 100;\n }\n const char* d = data::digits + exp * 2;\n *it++ = static_cast(d[0]);\n *it++ = static_cast(d[1]);\n return it;\n}\n\ntemplate class float_writer {\n private:\n // The number is given as v = digits_ * pow(10, exp_).\n const char* digits_;\n int num_digits_;\n int exp_;\n size_t size_;\n float_specs specs_;\n Char decimal_point_;\n\n template It prettify(It it) const {\n // pow(10, full_exp - 1) <= v <= pow(10, full_exp).\n int full_exp = num_digits_ + exp_;\n if (specs_.format == float_format::exp) {\n // Insert a decimal point after the first digit and add an exponent.\n *it++ = static_cast(*digits_);\n int num_zeros = specs_.precision - num_digits_;\n if (num_digits_ > 1 || specs_.showpoint) *it++ = decimal_point_;\n it = copy_str(digits_ + 1, digits_ + num_digits_, it);\n if (num_zeros > 0 && specs_.showpoint)\n it = std::fill_n(it, num_zeros, static_cast('0'));\n *it++ = static_cast(specs_.upper ? 'E' : 'e');\n return write_exponent(full_exp - 1, it);\n }\n if (num_digits_ <= full_exp) {\n // 1234e7 -> 12340000000[.0+]\n it = copy_str(digits_, digits_ + num_digits_, it);\n it = std::fill_n(it, full_exp - num_digits_, static_cast('0'));\n if (specs_.showpoint || specs_.precision < 0) {\n *it++ = decimal_point_;\n int num_zeros = specs_.precision - full_exp;\n if (num_zeros <= 0) {\n if (specs_.format != float_format::fixed)\n *it++ = static_cast('0');\n return it;\n }\n#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION\n if (num_zeros > 1000)\n throw std::runtime_error(\"fuzz mode - avoiding excessive cpu use\");\n#endif\n it = std::fill_n(it, num_zeros, static_cast('0'));\n }\n } else if (full_exp > 0) {\n // 1234e-2 -> 12.34[0+]\n it = copy_str(digits_, digits_ + full_exp, it);\n if (!specs_.showpoint) {\n // Remove trailing zeros.\n int num_digits = num_digits_;\n while (num_digits > full_exp && digits_[num_digits - 1] == '0')\n --num_digits;\n if (num_digits != full_exp) *it++ = decimal_point_;\n return copy_str(digits_ + full_exp, digits_ + num_digits, it);\n }\n *it++ = decimal_point_;\n it = copy_str(digits_ + full_exp, digits_ + num_digits_, it);\n if (specs_.precision > num_digits_) {\n // Add trailing zeros.\n int num_zeros = specs_.precision - num_digits_;\n it = std::fill_n(it, num_zeros, static_cast('0'));\n }\n } else {\n // 1234e-6 -> 0.001234\n *it++ = static_cast('0');\n int num_zeros = -full_exp;\n int num_digits = num_digits_;\n if (num_digits == 0 && specs_.precision >= 0 &&\n specs_.precision < num_zeros) {\n num_zeros = specs_.precision;\n }\n // Remove trailing zeros.\n if (!specs_.showpoint)\n while (num_digits > 0 && digits_[num_digits - 1] == '0') --num_digits;\n if (num_zeros != 0 || num_digits != 0 || specs_.showpoint) {\n *it++ = decimal_point_;\n it = std::fill_n(it, num_zeros, static_cast('0'));\n it = copy_str(digits_, digits_ + num_digits, it);\n }\n }\n return it;\n }\n\n public:\n float_writer(const char* digits, int num_digits, int exp, float_specs specs,\n Char decimal_point)\n : digits_(digits),\n num_digits_(num_digits),\n exp_(exp),\n specs_(specs),\n decimal_point_(decimal_point) {\n int full_exp = num_digits + exp - 1;\n int precision = specs.precision > 0 ? specs.precision : 16;\n if (specs_.format == float_format::general &&\n !(full_exp >= -4 && full_exp < precision)) {\n specs_.format = float_format::exp;\n }\n size_ = prettify(counting_iterator()).count();\n size_ += specs.sign ? 1 : 0;\n }\n\n size_t size() const { return size_; }\n size_t width() const { return size(); }\n\n template void operator()(It&& it) {\n if (specs_.sign) *it++ = static_cast(data::signs[specs_.sign]);\n it = prettify(it);\n }\n};\n\ntemplate \nint format_float(T value, int precision, float_specs specs, buffer& buf);\n\n// Formats a floating-point number with snprintf.\ntemplate \nint snprintf_float(T value, int precision, float_specs specs,\n buffer& buf);\n\ntemplate T promote_float(T value) { return value; }\ninline double promote_float(float value) { return static_cast(value); }\n\ntemplate \nFMT_CONSTEXPR void handle_int_type_spec(char spec, Handler&& handler) {\n switch (spec) {\n case 0:\n case 'd':\n handler.on_dec();\n break;\n case 'x':\n case 'X':\n handler.on_hex();\n break;\n case 'b':\n case 'B':\n handler.on_bin();\n break;\n case 'o':\n handler.on_oct();\n break;\n case 'n':\n case 'L':\n handler.on_num();\n break;\n default:\n handler.on_error();\n }\n}\n\ntemplate \nFMT_CONSTEXPR float_specs parse_float_type_spec(\n const basic_format_specs& specs, ErrorHandler&& eh = {}) {\n auto result = float_specs();\n result.showpoint = specs.alt;\n switch (specs.type) {\n case 0:\n result.format = float_format::general;\n result.showpoint |= specs.precision > 0;\n break;\n case 'G':\n result.upper = true;\n FMT_FALLTHROUGH;\n case 'g':\n result.format = float_format::general;\n break;\n case 'E':\n result.upper = true;\n FMT_FALLTHROUGH;\n case 'e':\n result.format = float_format::exp;\n result.showpoint |= specs.precision != 0;\n break;\n case 'F':\n result.upper = true;\n FMT_FALLTHROUGH;\n case 'f':\n result.format = float_format::fixed;\n result.showpoint |= specs.precision != 0;\n break;\n#if FMT_DEPRECATED_PERCENT\n case '%':\n result.format = float_format::fixed;\n result.percent = true;\n break;\n#endif\n case 'A':\n result.upper = true;\n FMT_FALLTHROUGH;\n case 'a':\n result.format = float_format::hex;\n break;\n case 'n':\n result.locale = true;\n break;\n default:\n eh.on_error(\"invalid type specifier\");\n break;\n }\n return result;\n}\n\ntemplate \nFMT_CONSTEXPR void handle_char_specs(const basic_format_specs* specs,\n Handler&& handler) {\n if (!specs) return handler.on_char();\n if (specs->type && specs->type != 'c') return handler.on_int();\n if (specs->align == align::numeric || specs->sign != sign::none || specs->alt)\n handler.on_error(\"invalid format specifier for char\");\n handler.on_char();\n}\n\ntemplate \nFMT_CONSTEXPR void handle_cstring_type_spec(Char spec, Handler&& handler) {\n if (spec == 0 || spec == 's')\n handler.on_string();\n else if (spec == 'p')\n handler.on_pointer();\n else\n handler.on_error(\"invalid type specifier\");\n}\n\ntemplate \nFMT_CONSTEXPR void check_string_type_spec(Char spec, ErrorHandler&& eh) {\n if (spec != 0 && spec != 's') eh.on_error(\"invalid type specifier\");\n}\n\ntemplate \nFMT_CONSTEXPR void check_pointer_type_spec(Char spec, ErrorHandler&& eh) {\n if (spec != 0 && spec != 'p') eh.on_error(\"invalid type specifier\");\n}\n\ntemplate class int_type_checker : private ErrorHandler {\n public:\n FMT_CONSTEXPR explicit int_type_checker(ErrorHandler eh) : ErrorHandler(eh) {}\n\n FMT_CONSTEXPR void on_dec() {}\n FMT_CONSTEXPR void on_hex() {}\n FMT_CONSTEXPR void on_bin() {}\n FMT_CONSTEXPR void on_oct() {}\n FMT_CONSTEXPR void on_num() {}\n\n FMT_CONSTEXPR void on_error() {\n ErrorHandler::on_error(\"invalid type specifier\");\n }\n};\n\ntemplate \nclass char_specs_checker : public ErrorHandler {\n private:\n char type_;\n\n public:\n FMT_CONSTEXPR char_specs_checker(char type, ErrorHandler eh)\n : ErrorHandler(eh), type_(type) {}\n\n FMT_CONSTEXPR void on_int() {\n handle_int_type_spec(type_, int_type_checker(*this));\n }\n FMT_CONSTEXPR void on_char() {}\n};\n\ntemplate \nclass cstring_type_checker : public ErrorHandler {\n public:\n FMT_CONSTEXPR explicit cstring_type_checker(ErrorHandler eh)\n : ErrorHandler(eh) {}\n\n FMT_CONSTEXPR void on_string() {}\n FMT_CONSTEXPR void on_pointer() {}\n};\n\ntemplate \nvoid arg_map::init(const basic_format_args& args) {\n if (map_) return;\n map_ = new entry[internal::to_unsigned(args.max_size())];\n if (args.is_packed()) {\n for (int i = 0;; ++i) {\n internal::type arg_type = args.type(i);\n if (arg_type == internal::type::none_type) return;\n if (arg_type == internal::type::named_arg_type)\n push_back(args.values_[i]);\n }\n }\n for (int i = 0, n = args.max_size(); i < n; ++i) {\n auto type = args.args_[i].type_;\n if (type == internal::type::named_arg_type) push_back(args.args_[i].value_);\n }\n}\n\ntemplate struct nonfinite_writer {\n sign_t sign;\n const char* str;\n static constexpr size_t str_size = 3;\n\n size_t size() const { return str_size + (sign ? 1 : 0); }\n size_t width() const { return size(); }\n\n template void operator()(It&& it) const {\n if (sign) *it++ = static_cast(data::signs[sign]);\n it = copy_str(str, str + str_size, it);\n }\n};\n\ntemplate \nFMT_NOINLINE OutputIt fill(OutputIt it, size_t n, const fill_t& fill) {\n auto fill_size = fill.size();\n if (fill_size == 1) return std::fill_n(it, n, fill[0]);\n for (size_t i = 0; i < n; ++i) it = std::copy_n(fill.data(), fill_size, it);\n return it;\n}\n\n// This template provides operations for formatting and writing data into a\n// character range.\ntemplate class basic_writer {\n public:\n using char_type = typename Range::value_type;\n using iterator = typename Range::iterator;\n using format_specs = basic_format_specs;\n\n private:\n iterator out_; // Output iterator.\n locale_ref locale_;\n\n // Attempts to reserve space for n extra characters in the output range.\n // Returns a pointer to the reserved range or a reference to out_.\n auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {\n return internal::reserve(out_, n);\n }\n\n template struct padded_int_writer {\n size_t size_;\n string_view prefix;\n char_type fill;\n std::size_t padding;\n F f;\n\n size_t size() const { return size_; }\n size_t width() const { return size_; }\n\n template void operator()(It&& it) const {\n if (prefix.size() != 0)\n it = copy_str(prefix.begin(), prefix.end(), it);\n it = std::fill_n(it, padding, fill);\n f(it);\n }\n };\n\n // Writes an integer in the format\n // \n // where are written by f(it).\n template \n void write_int(int num_digits, string_view prefix, format_specs specs, F f) {\n std::size_t size = prefix.size() + to_unsigned(num_digits);\n char_type fill = specs.fill[0];\n std::size_t padding = 0;\n if (specs.align == align::numeric) {\n auto unsiged_width = to_unsigned(specs.width);\n if (unsiged_width > size) {\n padding = unsiged_width - size;\n size = unsiged_width;\n }\n } else if (specs.precision > num_digits) {\n size = prefix.size() + to_unsigned(specs.precision);\n padding = to_unsigned(specs.precision - num_digits);\n fill = static_cast('0');\n }\n if (specs.align == align::none) specs.align = align::right;\n write_padded(specs, padded_int_writer{size, prefix, fill, padding, f});\n }\n\n // Writes a decimal integer.\n template void write_decimal(Int value) {\n auto abs_value = static_cast>(value);\n bool negative = is_negative(value);\n // Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.\n if (negative) abs_value = ~abs_value + 1;\n int num_digits = count_digits(abs_value);\n auto&& it = reserve((negative ? 1 : 0) + static_cast(num_digits));\n if (negative) *it++ = static_cast('-');\n it = format_decimal(it, abs_value, num_digits);\n }\n\n // The handle_int_type_spec handler that writes an integer.\n template struct int_writer {\n using unsigned_type = uint32_or_64_or_128_t;\n\n basic_writer& writer;\n const Specs& specs;\n unsigned_type abs_value;\n char prefix[4];\n unsigned prefix_size;\n\n string_view get_prefix() const { return string_view(prefix, prefix_size); }\n\n int_writer(basic_writer& w, Int value, const Specs& s)\n : writer(w),\n specs(s),\n abs_value(static_cast(value)),\n prefix_size(0) {\n if (is_negative(value)) {\n prefix[0] = '-';\n ++prefix_size;\n abs_value = 0 - abs_value;\n } else if (specs.sign != sign::none && specs.sign != sign::minus) {\n prefix[0] = specs.sign == sign::plus ? '+' : ' ';\n ++prefix_size;\n }\n }\n\n struct dec_writer {\n unsigned_type abs_value;\n int num_digits;\n\n template void operator()(It&& it) const {\n it = internal::format_decimal(it, abs_value, num_digits);\n }\n };\n\n void on_dec() {\n int num_digits = count_digits(abs_value);\n writer.write_int(num_digits, get_prefix(), specs,\n dec_writer{abs_value, num_digits});\n }\n\n struct hex_writer {\n int_writer& self;\n int num_digits;\n\n template void operator()(It&& it) const {\n it = format_uint<4, char_type>(it, self.abs_value, num_digits,\n self.specs.type != 'x');\n }\n };\n\n void on_hex() {\n if (specs.alt) {\n prefix[prefix_size++] = '0';\n prefix[prefix_size++] = specs.type;\n }\n int num_digits = count_digits<4>(abs_value);\n writer.write_int(num_digits, get_prefix(), specs,\n hex_writer{*this, num_digits});\n }\n\n template struct bin_writer {\n unsigned_type abs_value;\n int num_digits;\n\n template void operator()(It&& it) const {\n it = format_uint(it, abs_value, num_digits);\n }\n };\n\n void on_bin() {\n if (specs.alt) {\n prefix[prefix_size++] = '0';\n prefix[prefix_size++] = static_cast(specs.type);\n }\n int num_digits = count_digits<1>(abs_value);\n writer.write_int(num_digits, get_prefix(), specs,\n bin_writer<1>{abs_value, num_digits});\n }\n\n void on_oct() {\n int num_digits = count_digits<3>(abs_value);\n if (specs.alt && specs.precision <= num_digits && abs_value != 0) {\n // Octal prefix '0' is counted as a digit, so only add it if precision\n // is not greater than the number of digits.\n prefix[prefix_size++] = '0';\n }\n writer.write_int(num_digits, get_prefix(), specs,\n bin_writer<3>{abs_value, num_digits});\n }\n\n enum { sep_size = 1 };\n\n struct num_writer {\n unsigned_type abs_value;\n int size;\n const std::string& groups;\n char_type sep;\n\n template void operator()(It&& it) const {\n basic_string_view s(&sep, sep_size);\n // Index of a decimal digit with the least significant digit having\n // index 0.\n int digit_index = 0;\n std::string::const_iterator group = groups.cbegin();\n it = format_decimal(\n it, abs_value, size,\n [this, s, &group, &digit_index](char_type*& buffer) {\n if (*group <= 0 || ++digit_index % *group != 0 ||\n *group == max_value())\n return;\n if (group + 1 != groups.cend()) {\n digit_index = 0;\n ++group;\n }\n buffer -= s.size();\n std::uninitialized_copy(s.data(), s.data() + s.size(),\n make_checked(buffer, s.size()));\n });\n }\n };\n\n void on_num() {\n std::string groups = grouping(writer.locale_);\n if (groups.empty()) return on_dec();\n auto sep = thousands_sep(writer.locale_);\n if (!sep) return on_dec();\n int num_digits = count_digits(abs_value);\n int size = num_digits;\n std::string::const_iterator group = groups.cbegin();\n while (group != groups.cend() && num_digits > *group && *group > 0 &&\n *group != max_value()) {\n size += sep_size;\n num_digits -= *group;\n ++group;\n }\n if (group == groups.cend())\n size += sep_size * ((num_digits - 1) / groups.back());\n writer.write_int(size, get_prefix(), specs,\n num_writer{abs_value, size, groups, sep});\n }\n\n FMT_NORETURN void on_error() {\n FMT_THROW(format_error(\"invalid type specifier\"));\n }\n };\n\n template struct str_writer {\n const Char* s;\n size_t size_;\n\n size_t size() const { return size_; }\n size_t width() const {\n return count_code_points(basic_string_view(s, size_));\n }\n\n template void operator()(It&& it) const {\n it = copy_str(s, s + size_, it);\n }\n };\n\n struct bytes_writer {\n string_view bytes;\n\n size_t size() const { return bytes.size(); }\n size_t width() const { return bytes.size(); }\n\n template void operator()(It&& it) const {\n const char* data = bytes.data();\n it = copy_str(data, data + size(), it);\n }\n };\n\n template struct pointer_writer {\n UIntPtr value;\n int num_digits;\n\n size_t size() const { return to_unsigned(num_digits) + 2; }\n size_t width() const { return size(); }\n\n template void operator()(It&& it) const {\n *it++ = static_cast('0');\n *it++ = static_cast('x');\n it = format_uint<4, char_type>(it, value, num_digits);\n }\n };\n\n public:\n explicit basic_writer(Range out, locale_ref loc = locale_ref())\n : out_(out.begin()), locale_(loc) {}\n\n iterator out() const { return out_; }\n\n // Writes a value in the format\n // \n // where is written by f(it).\n template void write_padded(const format_specs& specs, F&& f) {\n // User-perceived width (in code points).\n unsigned width = to_unsigned(specs.width);\n size_t size = f.size(); // The number of code units.\n size_t num_code_points = width != 0 ? f.width() : size;\n if (width <= num_code_points) return f(reserve(size));\n size_t padding = width - num_code_points;\n size_t fill_size = specs.fill.size();\n auto&& it = reserve(size + padding * fill_size);\n if (specs.align == align::right) {\n it = fill(it, padding, specs.fill);\n f(it);\n } else if (specs.align == align::center) {\n std::size_t left_padding = padding / 2;\n it = fill(it, left_padding, specs.fill);\n f(it);\n it = fill(it, padding - left_padding, specs.fill);\n } else {\n f(it);\n it = fill(it, padding, specs.fill);\n }\n }\n\n void write(int value) { write_decimal(value); }\n void write(long value) { write_decimal(value); }\n void write(long long value) { write_decimal(value); }\n\n void write(unsigned value) { write_decimal(value); }\n void write(unsigned long value) { write_decimal(value); }\n void write(unsigned long long value) { write_decimal(value); }\n\n#if FMT_USE_INT128\n void write(int128_t value) { write_decimal(value); }\n void write(uint128_t value) { write_decimal(value); }\n#endif\n\n template \n void write_int(T value, const Spec& spec) {\n handle_int_type_spec(spec.type, int_writer(*this, value, spec));\n }\n\n template ::value)>\n void write(T value, format_specs specs = {}) {\n if (const_check(!is_supported_floating_point(value))) {\n return;\n }\n float_specs fspecs = parse_float_type_spec(specs);\n fspecs.sign = specs.sign;\n if (std::signbit(value)) { // value < 0 is false for NaN so use signbit.\n fspecs.sign = sign::minus;\n value = -value;\n } else if (fspecs.sign == sign::minus) {\n fspecs.sign = sign::none;\n }\n\n if (!std::isfinite(value)) {\n auto str = std::isinf(value) ? (fspecs.upper ? \"INF\" : \"inf\")\n : (fspecs.upper ? \"NAN\" : \"nan\");\n return write_padded(specs, nonfinite_writer{fspecs.sign, str});\n }\n\n if (specs.align == align::none) {\n specs.align = align::right;\n } else if (specs.align == align::numeric) {\n if (fspecs.sign) {\n auto&& it = reserve(1);\n *it++ = static_cast(data::signs[fspecs.sign]);\n fspecs.sign = sign::none;\n if (specs.width != 0) --specs.width;\n }\n specs.align = align::right;\n }\n\n memory_buffer buffer;\n if (fspecs.format == float_format::hex) {\n if (fspecs.sign) buffer.push_back(data::signs[fspecs.sign]);\n snprintf_float(promote_float(value), specs.precision, fspecs, buffer);\n write_padded(specs, str_writer{buffer.data(), buffer.size()});\n return;\n }\n int precision = specs.precision >= 0 || !specs.type ? specs.precision : 6;\n if (fspecs.format == float_format::exp) {\n if (precision == max_value())\n FMT_THROW(format_error(\"number is too big\"));\n else\n ++precision;\n }\n if (const_check(std::is_same())) fspecs.binary32 = true;\n fspecs.use_grisu = use_grisu();\n if (const_check(FMT_DEPRECATED_PERCENT) && fspecs.percent) value *= 100;\n int exp = format_float(promote_float(value), precision, fspecs, buffer);\n if (const_check(FMT_DEPRECATED_PERCENT) && fspecs.percent) {\n buffer.push_back('%');\n --exp; // Adjust decimal place position.\n }\n fspecs.precision = precision;\n char_type point = fspecs.locale ? decimal_point(locale_)\n : static_cast('.');\n write_padded(specs, float_writer(buffer.data(),\n static_cast(buffer.size()),\n exp, fspecs, point));\n }\n\n void write(char value) {\n auto&& it = reserve(1);\n *it++ = value;\n }\n\n template ::value)>\n void write(Char value) {\n auto&& it = reserve(1);\n *it++ = value;\n }\n\n void write(string_view value) {\n auto&& it = reserve(value.size());\n it = copy_str(value.begin(), value.end(), it);\n }\n void write(wstring_view value) {\n static_assert(std::is_same::value, \"\");\n auto&& it = reserve(value.size());\n it = std::copy(value.begin(), value.end(), it);\n }\n\n template \n void write(const Char* s, std::size_t size, const format_specs& specs) {\n write_padded(specs, str_writer{s, size});\n }\n\n template \n void write(basic_string_view s, const format_specs& specs = {}) {\n const Char* data = s.data();\n std::size_t size = s.size();\n if (specs.precision >= 0 && to_unsigned(specs.precision) < size)\n size = code_point_index(s, to_unsigned(specs.precision));\n write(data, size, specs);\n }\n\n void write_bytes(string_view bytes, const format_specs& specs) {\n write_padded(specs, bytes_writer{bytes});\n }\n\n template \n void write_pointer(UIntPtr value, const format_specs* specs) {\n int num_digits = count_digits<4>(value);\n auto pw = pointer_writer{value, num_digits};\n if (!specs) return pw(reserve(to_unsigned(num_digits) + 2));\n format_specs specs_copy = *specs;\n if (specs_copy.align == align::none) specs_copy.align = align::right;\n write_padded(specs_copy, pw);\n }\n};\n\nusing writer = basic_writer>;\n\ntemplate struct is_integral : std::is_integral {};\ntemplate <> struct is_integral : std::true_type {};\ntemplate <> struct is_integral : std::true_type {};\n\ntemplate \nclass arg_formatter_base {\n public:\n using char_type = typename Range::value_type;\n using iterator = typename Range::iterator;\n using format_specs = basic_format_specs;\n\n private:\n using writer_type = basic_writer;\n writer_type writer_;\n format_specs* specs_;\n\n struct char_writer {\n char_type value;\n\n size_t size() const { return 1; }\n size_t width() const { return 1; }\n\n template void operator()(It&& it) const { *it++ = value; }\n };\n\n void write_char(char_type value) {\n if (specs_)\n writer_.write_padded(*specs_, char_writer{value});\n else\n writer_.write(value);\n }\n\n void write_pointer(const void* p) {\n writer_.write_pointer(internal::to_uintptr(p), specs_);\n }\n\n protected:\n writer_type& writer() { return writer_; }\n FMT_DEPRECATED format_specs* spec() { return specs_; }\n format_specs* specs() { return specs_; }\n iterator out() { return writer_.out(); }\n\n void write(bool value) {\n string_view sv(value ? \"true\" : \"false\");\n specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);\n }\n\n void write(const char_type* value) {\n if (!value) {\n FMT_THROW(format_error(\"string pointer is null\"));\n } else {\n auto length = std::char_traits::length(value);\n basic_string_view sv(value, length);\n specs_ ? writer_.write(sv, *specs_) : writer_.write(sv);\n }\n }\n\n public:\n arg_formatter_base(Range r, format_specs* s, locale_ref loc)\n : writer_(r, loc), specs_(s) {}\n\n iterator operator()(monostate) {\n FMT_ASSERT(false, \"invalid argument type\");\n return out();\n }\n\n template ::value)>\n iterator operator()(T value) {\n if (specs_)\n writer_.write_int(value, *specs_);\n else\n writer_.write(value);\n return out();\n }\n\n iterator operator()(char_type value) {\n internal::handle_char_specs(\n specs_, char_spec_handler(*this, static_cast(value)));\n return out();\n }\n\n iterator operator()(bool value) {\n if (specs_ && specs_->type) return (*this)(value ? 1 : 0);\n write(value != 0);\n return out();\n }\n\n template ::value)>\n iterator operator()(T value) {\n if (const_check(is_supported_floating_point(value)))\n writer_.write(value, specs_ ? *specs_ : format_specs());\n else\n FMT_ASSERT(false, \"unsupported float argument type\");\n return out();\n }\n\n struct char_spec_handler : ErrorHandler {\n arg_formatter_base& formatter;\n char_type value;\n\n char_spec_handler(arg_formatter_base& f, char_type val)\n : formatter(f), value(val) {}\n\n void on_int() {\n if (formatter.specs_)\n formatter.writer_.write_int(value, *formatter.specs_);\n else\n formatter.writer_.write(value);\n }\n void on_char() { formatter.write_char(value); }\n };\n\n struct cstring_spec_handler : internal::error_handler {\n arg_formatter_base& formatter;\n const char_type* value;\n\n cstring_spec_handler(arg_formatter_base& f, const char_type* val)\n : formatter(f), value(val) {}\n\n void on_string() { formatter.write(value); }\n void on_pointer() { formatter.write_pointer(value); }\n };\n\n iterator operator()(const char_type* value) {\n if (!specs_) return write(value), out();\n internal::handle_cstring_type_spec(specs_->type,\n cstring_spec_handler(*this, value));\n return out();\n }\n\n iterator operator()(basic_string_view value) {\n if (specs_) {\n internal::check_string_type_spec(specs_->type, internal::error_handler());\n writer_.write(value, *specs_);\n } else {\n writer_.write(value);\n }\n return out();\n }\n\n iterator operator()(const void* value) {\n if (specs_)\n check_pointer_type_spec(specs_->type, internal::error_handler());\n write_pointer(value);\n return out();\n }\n};\n\ntemplate FMT_CONSTEXPR bool is_name_start(Char c) {\n return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || '_' == c;\n}\n\n// Parses the range [begin, end) as an unsigned integer. This function assumes\n// that the range is non-empty and the first character is a digit.\ntemplate \nFMT_CONSTEXPR int parse_nonnegative_int(const Char*& begin, const Char* end,\n ErrorHandler&& eh) {\n FMT_ASSERT(begin != end && '0' <= *begin && *begin <= '9', \"\");\n unsigned value = 0;\n // Convert to unsigned to prevent a warning.\n constexpr unsigned max_int = max_value();\n unsigned big = max_int / 10;\n do {\n // Check for overflow.\n if (value > big) {\n value = max_int + 1;\n break;\n }\n value = value * 10 + unsigned(*begin - '0');\n ++begin;\n } while (begin != end && '0' <= *begin && *begin <= '9');\n if (value > max_int) eh.on_error(\"number is too big\");\n return static_cast(value);\n}\n\ntemplate class custom_formatter {\n private:\n using char_type = typename Context::char_type;\n\n basic_format_parse_context& parse_ctx_;\n Context& ctx_;\n\n public:\n explicit custom_formatter(basic_format_parse_context& parse_ctx,\n Context& ctx)\n : parse_ctx_(parse_ctx), ctx_(ctx) {}\n\n bool operator()(typename basic_format_arg::handle h) const {\n h.format(parse_ctx_, ctx_);\n return true;\n }\n\n template bool operator()(T) const { return false; }\n};\n\ntemplate \nusing is_integer =\n bool_constant::value && !std::is_same::value &&\n !std::is_same::value &&\n !std::is_same::value>;\n\ntemplate class width_checker {\n public:\n explicit FMT_CONSTEXPR width_checker(ErrorHandler& eh) : handler_(eh) {}\n\n template ::value)>\n FMT_CONSTEXPR unsigned long long operator()(T value) {\n if (is_negative(value)) handler_.on_error(\"negative width\");\n return static_cast(value);\n }\n\n template ::value)>\n FMT_CONSTEXPR unsigned long long operator()(T) {\n handler_.on_error(\"width is not integer\");\n return 0;\n }\n\n private:\n ErrorHandler& handler_;\n};\n\ntemplate class precision_checker {\n public:\n explicit FMT_CONSTEXPR precision_checker(ErrorHandler& eh) : handler_(eh) {}\n\n template ::value)>\n FMT_CONSTEXPR unsigned long long operator()(T value) {\n if (is_negative(value)) handler_.on_error(\"negative precision\");\n return static_cast(value);\n }\n\n template ::value)>\n FMT_CONSTEXPR unsigned long long operator()(T) {\n handler_.on_error(\"precision is not integer\");\n return 0;\n }\n\n private:\n ErrorHandler& handler_;\n};\n\n// A format specifier handler that sets fields in basic_format_specs.\ntemplate class specs_setter {\n public:\n explicit FMT_CONSTEXPR specs_setter(basic_format_specs& specs)\n : specs_(specs) {}\n\n FMT_CONSTEXPR specs_setter(const specs_setter& other)\n : specs_(other.specs_) {}\n\n FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }\n FMT_CONSTEXPR void on_fill(basic_string_view fill) {\n specs_.fill = fill;\n }\n FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }\n FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }\n FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }\n FMT_CONSTEXPR void on_hash() { specs_.alt = true; }\n\n FMT_CONSTEXPR void on_zero() {\n specs_.align = align::numeric;\n specs_.fill[0] = Char('0');\n }\n\n FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }\n FMT_CONSTEXPR void on_precision(int precision) {\n specs_.precision = precision;\n }\n FMT_CONSTEXPR void end_precision() {}\n\n FMT_CONSTEXPR void on_type(Char type) {\n specs_.type = static_cast(type);\n }\n\n protected:\n basic_format_specs& specs_;\n};\n\ntemplate class numeric_specs_checker {\n public:\n FMT_CONSTEXPR numeric_specs_checker(ErrorHandler& eh, internal::type arg_type)\n : error_handler_(eh), arg_type_(arg_type) {}\n\n FMT_CONSTEXPR void require_numeric_argument() {\n if (!is_arithmetic_type(arg_type_))\n error_handler_.on_error(\"format specifier requires numeric argument\");\n }\n\n FMT_CONSTEXPR void check_sign() {\n require_numeric_argument();\n if (is_integral_type(arg_type_) && arg_type_ != type::int_type &&\n arg_type_ != type::long_long_type && arg_type_ != type::char_type) {\n error_handler_.on_error(\"format specifier requires signed argument\");\n }\n }\n\n FMT_CONSTEXPR void check_precision() {\n if (is_integral_type(arg_type_) || arg_type_ == type::pointer_type)\n error_handler_.on_error(\"precision not allowed for this argument type\");\n }\n\n private:\n ErrorHandler& error_handler_;\n internal::type arg_type_;\n};\n\n// A format specifier handler that checks if specifiers are consistent with the\n// argument type.\ntemplate class specs_checker : public Handler {\n public:\n FMT_CONSTEXPR specs_checker(const Handler& handler, internal::type arg_type)\n : Handler(handler), checker_(*this, arg_type) {}\n\n FMT_CONSTEXPR specs_checker(const specs_checker& other)\n : Handler(other), checker_(*this, other.arg_type_) {}\n\n FMT_CONSTEXPR void on_align(align_t align) {\n if (align == align::numeric) checker_.require_numeric_argument();\n Handler::on_align(align);\n }\n\n FMT_CONSTEXPR void on_plus() {\n checker_.check_sign();\n Handler::on_plus();\n }\n\n FMT_CONSTEXPR void on_minus() {\n checker_.check_sign();\n Handler::on_minus();\n }\n\n FMT_CONSTEXPR void on_space() {\n checker_.check_sign();\n Handler::on_space();\n }\n\n FMT_CONSTEXPR void on_hash() {\n checker_.require_numeric_argument();\n Handler::on_hash();\n }\n\n FMT_CONSTEXPR void on_zero() {\n checker_.require_numeric_argument();\n Handler::on_zero();\n }\n\n FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }\n\n private:\n numeric_specs_checker checker_;\n};\n\ntemplate