Copy disabled (too large)
Download .txt
Showing preview only (20,219K chars total). Download the full file to get everything.
Repository: pdeitel/CPlusPlus20FundamentalsLiveLessons
Branch: master
Commit: 555893304801
Files: 1954
Total size: 18.9 MB
Directory structure:
gitextract_ns33kz0v/
├── README.md
└── examples/
├── docker/
│ └── gcc13/
│ └── dockerfile
├── lesson01/
│ └── GuessNumber.cpp
├── lesson02/
│ ├── fig02_01.cpp
│ ├── fig02_02.cpp
│ ├── fig02_03.cpp
│ ├── fig02_04.cpp
│ ├── fig02_05.cpp
│ └── fig02_06.cpp
├── lesson03/
│ ├── fig03_01.cpp
│ ├── fig03_02.cpp
│ ├── fig03_03.cpp
│ ├── fig03_04.cpp
│ └── fig03_05.cpp
├── lesson04/
│ ├── decimalformatter.h
│ ├── decimalformatter_fmt.h
│ ├── ex04_06.cpp
│ ├── fig04_01.cpp
│ ├── fig04_02.cpp
│ ├── fig04_03.cpp
│ ├── fig04_03fmt.cpp
│ ├── fig04_04.cpp
│ ├── fig04_04fmt.cpp
│ ├── fig04_05.cpp
│ ├── fig04_06.cpp
│ ├── fig04_06fmt.cpp
│ ├── fig04_07.cpp
│ ├── fig04_07_with_error.cpp
│ ├── fig04_07fmt.cpp
│ ├── fig04_08.cpp
│ ├── fig04_09.cpp
│ ├── fig04_10.cpp
│ ├── fig04_11.cpp
│ ├── fig04_12/
│ │ ├── fig04_12.cpp
│ │ ├── fmt/
│ │ │ ├── core.h
│ │ │ ├── format-inl.h
│ │ │ └── format.h
│ │ └── format.cc
│ ├── fig04_17.cpp
│ └── fig04_17fmt.cpp
├── lesson05/
│ ├── cipher.h
│ ├── ex05_31.cpp
│ ├── fig05_01.cpp
│ ├── fig05_02.cpp
│ ├── fig05_03.cpp
│ ├── fig05_04.cpp
│ ├── fig05_05.cpp
│ ├── fig05_06.cpp
│ ├── fig05_07.cpp
│ ├── fig05_08.cpp
│ ├── fig05_09.cpp
│ ├── fig05_10.cpp
│ ├── fig05_11.cpp
│ ├── fig05_12.cpp
│ ├── fig05_13.cpp
│ ├── fig05_14.cpp
│ ├── fig05_15.cpp
│ ├── fig05_16.cpp
│ ├── fig05_17.cpp
│ ├── fig05_18.cpp
│ ├── fig05_19.cpp
│ ├── fig05_20.cpp
│ └── maximum.h
├── lesson06/
│ ├── fig06_01.cpp
│ ├── fig06_02.cpp
│ ├── fig06_03.cpp
│ ├── fig06_04.cpp
│ ├── fig06_05.cpp
│ ├── fig06_06.cpp
│ ├── fig06_07.cpp
│ ├── fig06_08.cpp
│ ├── fig06_09.cpp
│ ├── fig06_10.cpp
│ ├── fig06_11.cpp
│ ├── fig06_12.cpp
│ ├── fig06_13.cpp
│ └── fig06_14.cpp
├── lesson07/
│ ├── fig07_01.cpp
│ ├── fig07_02.cpp
│ ├── fig07_03.cpp
│ ├── fig07_06.cpp
│ ├── fig07_07.cpp
│ ├── fig07_08.cpp
│ ├── fig07_09.cpp
│ ├── fig07_10.cpp
│ ├── fig07_11.cpp
│ ├── fig07_12.cpp
│ ├── fig07_13.cpp
│ └── fig07_14.cpp
├── lesson08/
│ ├── accounts.csv
│ ├── fig08_01.cpp
│ ├── fig08_02.cpp
│ ├── fig08_03.cpp
│ ├── fig08_04.cpp
│ ├── fig08_05.cpp
│ ├── fig08_06.cpp
│ ├── fig08_07.cpp
│ ├── fig08_08.cpp
│ ├── fig08_09.cpp
│ ├── fig08_10.cpp
│ ├── fig08_11.cpp
│ ├── fig08_12.cpp
│ ├── fig08_13.cpp
│ ├── fig08_14.cpp
│ ├── fig08_15.cpp
│ ├── fig08_16.cpp
│ ├── fig08_17.cpp
│ ├── fig08_18.cpp
│ ├── format.cc
│ └── titanic.csv
├── lesson09/
│ ├── fig09_01-02/
│ │ ├── Account.h
│ │ └── AccountTest.cpp
│ ├── fig09_03-04/
│ │ ├── Account.h
│ │ └── AccountTest.cpp
│ ├── fig09_05-06/
│ │ ├── Account.h
│ │ └── AccountTest.cpp
│ ├── fig09_07-09/
│ │ ├── Time.cpp
│ │ ├── Time.h
│ │ └── fig09_09.cpp
│ ├── fig09_10-12/
│ │ ├── Time.cpp
│ │ ├── Time.h
│ │ └── fig09_12.cpp
│ ├── fig09_13-15/
│ │ ├── CreateAndDestroy.cpp
│ │ ├── CreateAndDestroy.h
│ │ └── fig09_15.cpp
│ ├── fig09_16-18/
│ │ ├── Time.cpp
│ │ ├── Time.h
│ │ └── fig09_18.cpp
│ ├── fig09_19-21/
│ │ ├── Date.cpp
│ │ ├── Date.h
│ │ └── fig09_21.cpp
│ ├── fig09_22/
│ │ ├── Time.cpp
│ │ ├── Time.h
│ │ └── fig09_22.cpp
│ ├── fig09_23-27/
│ │ ├── Date.cpp
│ │ ├── Date.h
│ │ ├── Employee.cpp
│ │ ├── Employee.h
│ │ └── fig09_27.cpp
│ ├── fig09_28/
│ │ └── fig09_28.cpp
│ ├── fig09_29/
│ │ └── fig09_29.cpp
│ ├── fig09_30-32/
│ │ ├── Time.cpp
│ │ ├── Time.h
│ │ └── fig09_32.cpp
│ ├── fig09_33-35/
│ │ ├── Employee.cpp
│ │ ├── Employee.h
│ │ └── fig09_35.cpp
│ ├── fig09_36-37/
│ │ ├── cipher.h
│ │ └── fig09_36.cpp
│ └── fig09_38/
│ ├── fig09_38.cpp
│ └── records.json
├── lesson10/
│ ├── fig10_01-03/
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_03.cpp
│ ├── fig10_04-06/
│ │ ├── SalariedCommissionEmployee.cpp
│ │ ├── SalariedCommissionEmployee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_06.cpp
│ ├── fig10_07/
│ │ ├── SalariedCommissionEmployee.cpp
│ │ ├── SalariedCommissionEmployee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_07.cpp
│ ├── fig10_08/
│ │ ├── SalariedCommissionEmployee.cpp
│ │ ├── SalariedCommissionEmployee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_08.cpp
│ ├── fig10_09/
│ │ ├── SalariedCommissionEmployee.cpp
│ │ ├── SalariedCommissionEmployee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_09.cpp
│ ├── fig10_10/
│ │ ├── SalariedCommissionEmployee.cpp
│ │ ├── SalariedCommissionEmployee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_10.cpp
│ ├── fig10_11-17/
│ │ ├── CommissionEmployee.cpp
│ │ ├── CommissionEmployee.h
│ │ ├── Employee.cpp
│ │ ├── Employee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_17.cpp
│ └── fig10_19-26/
│ ├── Commission.cpp
│ ├── Commission.h
│ ├── CompensationModel.h
│ ├── Employee.cpp
│ ├── Employee.h
│ ├── Salaried.cpp
│ ├── Salaried.h
│ └── fig10_26.cpp
├── lesson11/
│ ├── fig11_01/
│ │ └── fig11_01.cpp
│ ├── fig11_02/
│ │ └── fig11_02.cpp
│ ├── fig11_03-05/
│ │ ├── MyArray.cpp
│ │ ├── MyArray.h
│ │ ├── a.out
│ │ └── fig11_03.cpp
│ ├── fig11_06/
│ │ └── fig11_06.cpp
│ ├── fig11_07/
│ │ ├── MyArray.cpp
│ │ ├── MyArray.h
│ │ └── fig11_07.cpp
│ └── fig11_08/
│ ├── MyArray.cpp
│ ├── MyArray.h
│ └── fig11_08.cpp
├── lesson12/
│ ├── fig12_01-02/
│ │ ├── DivideByZeroException.h
│ │ └── fig12_02.cpp
│ ├── fig12_03/
│ │ └── fig12_03.cpp
│ ├── fig12_04/
│ │ ├── fig12_04.cpp
│ │ └── fig12_04modified.cpp
│ ├── fig12_05/
│ │ └── fig12_05.cpp
│ ├── fig12_06/
│ │ └── fig12_06.cpp
│ ├── fig12_07/
│ │ └── fig12_07.cpp
│ ├── fig12_08/
│ │ └── fig12_08.cpp
│ └── fig12_09/
│ └── fig12_09.cpp
├── lesson13/
│ ├── fig13_01.cpp
│ ├── fig13_02.cpp
│ ├── fig13_03.cpp
│ ├── fig13_04.cpp
│ ├── fig13_05.cpp
│ ├── fig13_06.cpp
│ ├── fig13_07.cpp
│ ├── fig13_08.cpp
│ ├── fig13_09.cpp
│ ├── fig13_10.cpp
│ ├── fig13_11.cpp
│ └── fig13_12.cpp
├── lesson14/
│ ├── fig14_01.cpp
│ ├── fig14_02.cpp
│ ├── fig14_03.cpp
│ ├── fig14_04.cpp
│ ├── fig14_05.cpp
│ ├── fig14_06.cpp
│ ├── fig14_07.cpp
│ ├── fig14_08.cpp
│ ├── fig14_09.cpp
│ ├── fig14_10.cpp
│ ├── fig14_11.cpp
│ ├── fig14_12.cpp
│ ├── fig14_13.cpp
│ ├── fig14_14.cpp
│ ├── fig14_15.cpp
│ ├── fig14_16.cpp
│ ├── fig14_17.cpp
│ └── fig14_18.cpp
├── lesson15/
│ ├── fig15_01-02/
│ │ ├── Stack.h
│ │ └── fig15_02.cpp
│ ├── fig15_03.cpp
│ ├── fig15_04.cpp
│ ├── fig15_05.cpp
│ ├── fig15_06.cpp
│ ├── fig15_07.cpp
│ ├── fig15_08.cpp
│ ├── fig15_09.cpp
│ ├── fig15_10.cpp
│ ├── fig15_11-12/
│ │ ├── MyArray.h
│ │ ├── fig15_12.cpp
│ │ └── sorttest.cpp
│ ├── fig15_13.cpp
│ ├── fig15_14.cpp
│ ├── fig15_15.cpp
│ ├── fig15_16.cpp
│ ├── fig15_17.cpp
│ ├── fig15_18.cpp
│ ├── fig15_19.cpp
│ ├── fig15_20.cpp
│ └── fig15_21.cpp
├── lesson16/
│ ├── compilation_commands.txt
│ ├── fig16_01/
│ │ └── fig16_01.cpp
│ ├── fig16_02-03/
│ │ ├── fig16_03.cpp
│ │ └── welcome.ixx
│ ├── fig16_04-05/
│ │ ├── deitel.math.ixx
│ │ └── fig16_05.cpp
│ ├── fig16_06-08/
│ │ ├── deitel.math-impl.cpp
│ │ ├── deitel.math.ixx
│ │ └── fig16_08.cpp
│ ├── fig16_09-11/
│ │ ├── deitel.time-impl.cpp
│ │ ├── deitel.time.ixx
│ │ └── fig16_11.cpp
│ ├── fig16_12-15/
│ │ ├── deitel.math-powers.ixx
│ │ ├── deitel.math-roots.ixx
│ │ ├── deitel.math.ixx
│ │ └── fig16_15.cpp
│ ├── fig16_12-15clang/
│ │ ├── deitel.math-powers.ixx
│ │ ├── deitel.math-roots.ixx
│ │ ├── deitel.math.ixx
│ │ └── fig16_15.cpp
│ ├── fig16_16-21/
│ │ ├── deitel.math.ixx
│ │ ├── deitel.math.powers.ixx
│ │ ├── deitel.math.roots.ixx
│ │ ├── fig16_17.cpp
│ │ ├── fig16_19.cpp
│ │ └── fig16_21.cpp
│ ├── fig16_16-21clang/
│ │ ├── deitel.math.ixx
│ │ ├── deitel.math.powers.ixx
│ │ ├── deitel.math.roots.ixx
│ │ ├── fig16_17.cpp
│ │ ├── fig16_19.cpp
│ │ └── fig16_21.cpp
│ ├── fig16_22/
│ │ └── fig16_22.cpp
│ ├── fig16_23-24/
│ │ ├── moduleA.ixx
│ │ └── moduleB.ixx
│ ├── fig16_25-27/
│ │ ├── fig16_27.cpp
│ │ ├── moduleA.ixx
│ │ └── moduleB.ixx
│ └── fig16_28-29/
│ ├── deitel.time-impl.cpp
│ ├── deitel.time.ixx
│ └── fig16_29.cpp
├── lesson17/
│ ├── fig17_01/
│ │ └── fig17_01.cpp
│ ├── fig17_02/
│ │ └── fig17_02.cpp
│ ├── fig17_03-04/
│ │ ├── printtask.cpp
│ │ └── printtask.h
│ ├── fig17_05-06/
│ │ ├── SharedBufferTest.cpp
│ │ └── UnsynchronizedBuffer.h
│ ├── fig17_07-08/
│ │ ├── SharedBufferTest.cpp
│ │ └── SynchronizedBuffer.h
│ ├── fig17_09-10/
│ │ ├── CircularBuffer.h
│ │ └── SharedBufferTest.cpp
│ ├── fig17_11/
│ │ ├── CooperativeCancelation.cpp
│ │ └── CooperativeCancelationFMT.cpp
│ ├── fig17_12/
│ │ ├── async.cpp
│ │ ├── async.o
│ │ └── format.o
│ ├── fig17_13/
│ │ └── atomic.cpp
│ ├── fig17_14/
│ │ └── LatchDemo.cpp
│ ├── fig17_15/
│ │ └── BarrierDemo.cpp
│ └── fig17_16/
│ ├── SharedBufferTest.cpp
│ └── SynchronizedBuffer.h
├── lesson18/
│ ├── fig18_01.cpp
│ ├── fig18_02.cpp
│ ├── fig18_03.cpp
│ └── vcpkg.json
├── lesson19/
│ ├── fig19_01.cpp
│ ├── fig19_02.cpp
│ ├── fig19_03.cpp
│ ├── fig19_04.cpp
│ ├── fig19_05.cpp
│ ├── fig19_06.cpp
│ ├── fig19_07.cpp
│ ├── fig19_08.cpp
│ ├── fig19_09.cpp
│ ├── fig19_10.cpp
│ ├── fig19_11.cpp
│ ├── fig19_12.cpp
│ ├── fig19_13.cpp
│ ├── fig19_14.cpp
│ ├── fig19_15.cpp
│ ├── fig19_16.cpp
│ ├── fig19_17.cpp
│ ├── fig19_18.cpp
│ ├── fig19_19.cpp
│ ├── fig19_20.cpp
│ ├── fig19_21.cpp
│ ├── fig19_22.cpp
│ └── fig19_23.cpp
├── lesson20/
│ ├── fig20_01.cpp
│ ├── fig20_02.cpp
│ ├── fig20_03.cpp
│ ├── fig20_04.cpp
│ ├── fig20_05.cpp
│ ├── fig20_06/
│ │ ├── CommissionEmployee.cpp
│ │ ├── CommissionEmployee.h
│ │ ├── Employee.cpp
│ │ ├── Employee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig20_06.cpp
│ ├── fig20_07.cpp
│ ├── fig20_08.cpp
│ ├── fig20_09-13/
│ │ ├── Author.cpp
│ │ ├── Author.h
│ │ ├── Book.cpp
│ │ ├── Book.h
│ │ └── fig20_13.cpp
│ └── fig20_14.cpp
├── libraries/
│ ├── BigNumber/
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE.md
│ │ ├── README.md
│ │ ├── bin/
│ │ │ └── BigNumber/
│ │ │ ├── include/
│ │ │ │ └── bignumber.h
│ │ │ └── lib/
│ │ │ └── libBigNumber.a
│ │ ├── main.cpp
│ │ └── src/
│ │ ├── bignumber.cpp
│ │ └── bignumber.h
│ ├── GSL/
│ │ ├── .clang-format
│ │ ├── .github/
│ │ │ └── workflows/
│ │ │ └── main.yml
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── CMakeLists.txt
│ │ ├── CMakeSettings.json
│ │ ├── CONTRIBUTING.md
│ │ ├── GSL.natvis
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── ThirdPartyNotices.txt
│ │ ├── appveyor.yml
│ │ ├── include/
│ │ │ └── gsl/
│ │ │ ├── gsl
│ │ │ ├── gsl_algorithm
│ │ │ ├── gsl_assert
│ │ │ ├── gsl_byte
│ │ │ ├── gsl_util
│ │ │ ├── multi_span
│ │ │ ├── pointers
│ │ │ ├── span
│ │ │ ├── span_ext
│ │ │ └── string_span
│ │ └── tests/
│ │ ├── CMakeLists.txt
│ │ ├── CMakeLists.txt.in
│ │ ├── algorithm_tests.cpp
│ │ ├── assertion_tests.cpp
│ │ ├── at_tests.cpp
│ │ ├── bounds_tests.cpp
│ │ ├── byte_tests.cpp
│ │ ├── multi_span_tests.cpp
│ │ ├── no_exception_ensure_tests.cpp
│ │ ├── notnull_tests.cpp
│ │ ├── owner_tests.cpp
│ │ ├── span_compatibility_tests.cpp
│ │ ├── span_ext_tests.cpp
│ │ ├── span_tests.cpp
│ │ ├── strict_notnull_tests.cpp
│ │ ├── strided_span_tests.cpp
│ │ ├── string_span_tests.cpp
│ │ └── utils_tests.cpp
│ ├── cereal-1.3.0/
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── appveyor.yml
│ │ ├── doc/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── DoxygenLayout.xml
│ │ │ ├── doxygen.in
│ │ │ ├── footer.html
│ │ │ └── mainpage.dox
│ │ ├── include/
│ │ │ └── cereal/
│ │ │ ├── access.hpp
│ │ │ ├── archives/
│ │ │ │ ├── adapters.hpp
│ │ │ │ ├── binary.hpp
│ │ │ │ ├── json.hpp
│ │ │ │ ├── portable_binary.hpp
│ │ │ │ └── xml.hpp
│ │ │ ├── cereal.hpp
│ │ │ ├── details/
│ │ │ │ ├── helpers.hpp
│ │ │ │ ├── polymorphic_impl.hpp
│ │ │ │ ├── polymorphic_impl_fwd.hpp
│ │ │ │ ├── static_object.hpp
│ │ │ │ ├── traits.hpp
│ │ │ │ └── util.hpp
│ │ │ ├── external/
│ │ │ │ ├── base64.hpp
│ │ │ │ ├── rapidjson/
│ │ │ │ │ ├── allocators.h
│ │ │ │ │ ├── cursorstreamwrapper.h
│ │ │ │ │ ├── document.h
│ │ │ │ │ ├── encodedstream.h
│ │ │ │ │ ├── encodings.h
│ │ │ │ │ ├── error/
│ │ │ │ │ │ ├── en.h
│ │ │ │ │ │ └── error.h
│ │ │ │ │ ├── filereadstream.h
│ │ │ │ │ ├── filewritestream.h
│ │ │ │ │ ├── fwd.h
│ │ │ │ │ ├── internal/
│ │ │ │ │ │ ├── biginteger.h
│ │ │ │ │ │ ├── diyfp.h
│ │ │ │ │ │ ├── dtoa.h
│ │ │ │ │ │ ├── ieee754.h
│ │ │ │ │ │ ├── itoa.h
│ │ │ │ │ │ ├── meta.h
│ │ │ │ │ │ ├── pow10.h
│ │ │ │ │ │ ├── regex.h
│ │ │ │ │ │ ├── stack.h
│ │ │ │ │ │ ├── strfunc.h
│ │ │ │ │ │ ├── strtod.h
│ │ │ │ │ │ └── swap.h
│ │ │ │ │ ├── istreamwrapper.h
│ │ │ │ │ ├── memorybuffer.h
│ │ │ │ │ ├── memorystream.h
│ │ │ │ │ ├── msinttypes/
│ │ │ │ │ │ ├── inttypes.h
│ │ │ │ │ │ └── stdint.h
│ │ │ │ │ ├── ostreamwrapper.h
│ │ │ │ │ ├── pointer.h
│ │ │ │ │ ├── prettywriter.h
│ │ │ │ │ ├── rapidjson.h
│ │ │ │ │ ├── reader.h
│ │ │ │ │ ├── schema.h
│ │ │ │ │ ├── stream.h
│ │ │ │ │ ├── stringbuffer.h
│ │ │ │ │ └── writer.h
│ │ │ │ └── rapidxml/
│ │ │ │ ├── license.txt
│ │ │ │ ├── manual.html
│ │ │ │ ├── rapidxml.hpp
│ │ │ │ ├── rapidxml_iterators.hpp
│ │ │ │ ├── rapidxml_print.hpp
│ │ │ │ └── rapidxml_utils.hpp
│ │ │ ├── macros.hpp
│ │ │ ├── specialize.hpp
│ │ │ ├── types/
│ │ │ │ ├── array.hpp
│ │ │ │ ├── atomic.hpp
│ │ │ │ ├── base_class.hpp
│ │ │ │ ├── bitset.hpp
│ │ │ │ ├── boost_variant.hpp
│ │ │ │ ├── chrono.hpp
│ │ │ │ ├── common.hpp
│ │ │ │ ├── complex.hpp
│ │ │ │ ├── concepts/
│ │ │ │ │ └── pair_associative_container.hpp
│ │ │ │ ├── deque.hpp
│ │ │ │ ├── forward_list.hpp
│ │ │ │ ├── functional.hpp
│ │ │ │ ├── list.hpp
│ │ │ │ ├── map.hpp
│ │ │ │ ├── memory.hpp
│ │ │ │ ├── optional.hpp
│ │ │ │ ├── polymorphic.hpp
│ │ │ │ ├── queue.hpp
│ │ │ │ ├── set.hpp
│ │ │ │ ├── stack.hpp
│ │ │ │ ├── string.hpp
│ │ │ │ ├── tuple.hpp
│ │ │ │ ├── unordered_map.hpp
│ │ │ │ ├── unordered_set.hpp
│ │ │ │ ├── utility.hpp
│ │ │ │ ├── valarray.hpp
│ │ │ │ ├── variant.hpp
│ │ │ │ └── vector.hpp
│ │ │ └── version.hpp
│ │ ├── sandbox/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── performance.cpp
│ │ │ ├── sandbox.cpp
│ │ │ ├── sandbox_json.cpp
│ │ │ ├── sandbox_rtti.cpp
│ │ │ ├── sandbox_shared_lib/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── base.cpp
│ │ │ │ ├── base.hpp
│ │ │ │ ├── derived.cpp
│ │ │ │ └── derived.hpp
│ │ │ └── sandbox_vs.cpp
│ │ ├── scripts/
│ │ │ ├── add_rapidjson_prefix.sh
│ │ │ ├── appveyor.bat
│ │ │ ├── renameincludes.sh
│ │ │ ├── updatecoverage.sh
│ │ │ └── updatedoc.in
│ │ └── unittests/
│ │ ├── CMakeLists.txt
│ │ ├── array.cpp
│ │ ├── array.hpp
│ │ ├── atomic.cpp
│ │ ├── atomic.hpp
│ │ ├── basic_string.cpp
│ │ ├── basic_string.hpp
│ │ ├── bitset.cpp
│ │ ├── bitset.hpp
│ │ ├── boost/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── boost_variant.cpp
│ │ │ └── boost_variant.hpp
│ │ ├── chrono.cpp
│ │ ├── chrono.hpp
│ │ ├── cmake-config-module.cmake
│ │ ├── common.hpp
│ │ ├── complex.cpp
│ │ ├── complex.hpp
│ │ ├── cpp17/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── optional.cpp
│ │ │ ├── optional.hpp
│ │ │ ├── variant.cpp
│ │ │ └── variant.hpp
│ │ ├── defer.cpp
│ │ ├── defer.hpp
│ │ ├── deque.cpp
│ │ ├── deque.hpp
│ │ ├── doctest.h
│ │ ├── forward_list.cpp
│ │ ├── forward_list.hpp
│ │ ├── list.cpp
│ │ ├── list.hpp
│ │ ├── load_construct.cpp
│ │ ├── load_construct.hpp
│ │ ├── map.cpp
│ │ ├── map.hpp
│ │ ├── memory.cpp
│ │ ├── memory.hpp
│ │ ├── memory_cycles.cpp
│ │ ├── memory_cycles.hpp
│ │ ├── multimap.cpp
│ │ ├── multimap.hpp
│ │ ├── multiset.cpp
│ │ ├── multiset.hpp
│ │ ├── pair.cpp
│ │ ├── pair.hpp
│ │ ├── pod.cpp
│ │ ├── pod.hpp
│ │ ├── polymorphic.cpp
│ │ ├── polymorphic.hpp
│ │ ├── portability_test.cpp
│ │ ├── portable_binary_archive.cpp
│ │ ├── portable_binary_archive.hpp
│ │ ├── priority_queue.cpp
│ │ ├── priority_queue.hpp
│ │ ├── queue.cpp
│ │ ├── queue.hpp
│ │ ├── run_portability_test.cmake
│ │ ├── run_valgrind.sh
│ │ ├── set.cpp
│ │ ├── set.hpp
│ │ ├── stack.cpp
│ │ ├── stack.hpp
│ │ ├── structs.cpp
│ │ ├── structs.hpp
│ │ ├── structs_minimal.cpp
│ │ ├── structs_minimal.hpp
│ │ ├── structs_specialized.cpp
│ │ ├── structs_specialized.hpp
│ │ ├── tuple.cpp
│ │ ├── tuple.hpp
│ │ ├── unordered_loads.cpp
│ │ ├── unordered_loads.hpp
│ │ ├── unordered_map.cpp
│ │ ├── unordered_map.hpp
│ │ ├── unordered_multimap.cpp
│ │ ├── unordered_multimap.hpp
│ │ ├── unordered_multiset.cpp
│ │ ├── unordered_multiset.hpp
│ │ ├── unordered_set.cpp
│ │ ├── unordered_set.hpp
│ │ ├── user_data_adapters.cpp
│ │ ├── user_data_adapters.hpp
│ │ ├── valarray.cpp
│ │ ├── valarray.hpp
│ │ ├── vector.cpp
│ │ ├── vector.hpp
│ │ ├── versioning.cpp
│ │ └── versioning.hpp
│ ├── fmt/
│ │ ├── .clang-format
│ │ ├── .github/
│ │ │ ├── pull_request_template.md
│ │ │ └── workflows/
│ │ │ ├── doc.yml
│ │ │ ├── linux.yml
│ │ │ ├── macos.yml
│ │ │ └── windows.yml
│ │ ├── .gitignore
│ │ ├── CMakeLists.txt
│ │ ├── CONTRIBUTING.md
│ │ ├── ChangeLog.rst
│ │ ├── LICENSE.rst
│ │ ├── README.rst
│ │ ├── doc/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── _static/
│ │ │ │ └── breathe.css
│ │ │ ├── _templates/
│ │ │ │ ├── layout.html
│ │ │ │ └── search.html
│ │ │ ├── api.rst
│ │ │ ├── basic-bootstrap/
│ │ │ │ ├── README
│ │ │ │ ├── layout.html
│ │ │ │ └── theme.conf
│ │ │ ├── bootstrap/
│ │ │ │ ├── alerts.less
│ │ │ │ ├── badges.less
│ │ │ │ ├── bootstrap.less
│ │ │ │ ├── breadcrumbs.less
│ │ │ │ ├── button-groups.less
│ │ │ │ ├── buttons.less
│ │ │ │ ├── carousel.less
│ │ │ │ ├── close.less
│ │ │ │ ├── code.less
│ │ │ │ ├── component-animations.less
│ │ │ │ ├── dropdowns.less
│ │ │ │ ├── forms.less
│ │ │ │ ├── glyphicons.less
│ │ │ │ ├── grid.less
│ │ │ │ ├── input-groups.less
│ │ │ │ ├── jumbotron.less
│ │ │ │ ├── labels.less
│ │ │ │ ├── list-group.less
│ │ │ │ ├── media.less
│ │ │ │ ├── mixins/
│ │ │ │ │ ├── alerts.less
│ │ │ │ │ ├── background-variant.less
│ │ │ │ │ ├── border-radius.less
│ │ │ │ │ ├── buttons.less
│ │ │ │ │ ├── center-block.less
│ │ │ │ │ ├── clearfix.less
│ │ │ │ │ ├── forms.less
│ │ │ │ │ ├── gradients.less
│ │ │ │ │ ├── grid-framework.less
│ │ │ │ │ ├── grid.less
│ │ │ │ │ ├── hide-text.less
│ │ │ │ │ ├── image.less
│ │ │ │ │ ├── labels.less
│ │ │ │ │ ├── list-group.less
│ │ │ │ │ ├── nav-divider.less
│ │ │ │ │ ├── nav-vertical-align.less
│ │ │ │ │ ├── opacity.less
│ │ │ │ │ ├── pagination.less
│ │ │ │ │ ├── panels.less
│ │ │ │ │ ├── progress-bar.less
│ │ │ │ │ ├── reset-filter.less
│ │ │ │ │ ├── resize.less
│ │ │ │ │ ├── responsive-visibility.less
│ │ │ │ │ ├── size.less
│ │ │ │ │ ├── tab-focus.less
│ │ │ │ │ ├── table-row.less
│ │ │ │ │ ├── text-emphasis.less
│ │ │ │ │ ├── text-overflow.less
│ │ │ │ │ └── vendor-prefixes.less
│ │ │ │ ├── mixins.less
│ │ │ │ ├── modals.less
│ │ │ │ ├── navbar.less
│ │ │ │ ├── navs.less
│ │ │ │ ├── normalize.less
│ │ │ │ ├── pager.less
│ │ │ │ ├── pagination.less
│ │ │ │ ├── panels.less
│ │ │ │ ├── popovers.less
│ │ │ │ ├── print.less
│ │ │ │ ├── progress-bars.less
│ │ │ │ ├── responsive-embed.less
│ │ │ │ ├── responsive-utilities.less
│ │ │ │ ├── scaffolding.less
│ │ │ │ ├── tables.less
│ │ │ │ ├── theme.less
│ │ │ │ ├── thumbnails.less
│ │ │ │ ├── tooltip.less
│ │ │ │ ├── type.less
│ │ │ │ ├── utilities.less
│ │ │ │ ├── variables.less
│ │ │ │ └── wells.less
│ │ │ ├── build.py
│ │ │ ├── conf.py
│ │ │ ├── contents.rst
│ │ │ ├── fmt.less
│ │ │ ├── index.rst
│ │ │ ├── python-license.txt
│ │ │ ├── syntax.rst
│ │ │ └── usage.rst
│ │ ├── include/
│ │ │ └── fmt/
│ │ │ ├── args.h
│ │ │ ├── chrono.h
│ │ │ ├── color.h
│ │ │ ├── compile.h
│ │ │ ├── core.h
│ │ │ ├── format-inl.h
│ │ │ ├── format.h
│ │ │ ├── locale.h
│ │ │ ├── os.h
│ │ │ ├── ostream.h
│ │ │ ├── printf.h
│ │ │ ├── ranges.h
│ │ │ └── xchar.h
│ │ ├── src/
│ │ │ ├── fmt.cc
│ │ │ ├── format.cc
│ │ │ └── os.cc
│ │ ├── support/
│ │ │ ├── Android.mk
│ │ │ ├── AndroidManifest.xml
│ │ │ ├── C++.sublime-syntax
│ │ │ ├── README
│ │ │ ├── Vagrantfile
│ │ │ ├── appveyor-build.py
│ │ │ ├── appveyor.yml
│ │ │ ├── build-docs.py
│ │ │ ├── build.gradle
│ │ │ ├── cmake/
│ │ │ │ ├── FindSetEnv.cmake
│ │ │ │ ├── JoinPaths.cmake
│ │ │ │ ├── cxx14.cmake
│ │ │ │ ├── fmt-config.cmake.in
│ │ │ │ └── fmt.pc.in
│ │ │ ├── compute-powers.py
│ │ │ ├── docopt.py
│ │ │ ├── manage.py
│ │ │ ├── rst2md.py
│ │ │ └── rtd/
│ │ │ ├── conf.py
│ │ │ ├── index.rst
│ │ │ └── theme/
│ │ │ ├── layout.html
│ │ │ └── theme.conf
│ │ └── test/
│ │ ├── CMakeLists.txt
│ │ ├── add-subdirectory-test/
│ │ │ ├── CMakeLists.txt
│ │ │ └── main.cc
│ │ ├── args-test.cc
│ │ ├── assert-test.cc
│ │ ├── chrono-test.cc
│ │ ├── color-test.cc
│ │ ├── compile-error-test/
│ │ │ └── CMakeLists.txt
│ │ ├── compile-test.cc
│ │ ├── core-test.cc
│ │ ├── cuda-test/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── cpp14.cc
│ │ │ └── cuda-cpp14.cu
│ │ ├── enforce-checks-test.cc
│ │ ├── find-package-test/
│ │ │ ├── CMakeLists.txt
│ │ │ └── main.cc
│ │ ├── format
│ │ ├── format-impl-test.cc
│ │ ├── format-test.cc
│ │ ├── fuzzing/
│ │ │ ├── .gitignore
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── build.sh
│ │ │ ├── chrono-duration.cc
│ │ │ ├── float.cc
│ │ │ ├── fuzzer-common.h
│ │ │ ├── main.cc
│ │ │ ├── named-arg.cc
│ │ │ ├── one-arg.cc
│ │ │ └── two-args.cc
│ │ ├── gtest/
│ │ │ ├── .clang-format
│ │ │ ├── CMakeLists.txt
│ │ │ ├── gmock/
│ │ │ │ └── gmock.h
│ │ │ ├── gmock-gtest-all.cc
│ │ │ └── gtest/
│ │ │ ├── gtest-spi.h
│ │ │ └── gtest.h
│ │ ├── gtest-extra-test.cc
│ │ ├── gtest-extra.cc
│ │ ├── gtest-extra.h
│ │ ├── header-only-test.cc
│ │ ├── mock-allocator.h
│ │ ├── module-test.cc
│ │ ├── os-test.cc
│ │ ├── ostream-test.cc
│ │ ├── posix-mock-test.cc
│ │ ├── posix-mock.h
│ │ ├── printf-test.cc
│ │ ├── ranges-test.cc
│ │ ├── scan-test.cc
│ │ ├── scan.h
│ │ ├── static-export-test/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── library.cc
│ │ │ └── main.cc
│ │ ├── std-format-test.cc
│ │ ├── test-assert.h
│ │ ├── test-main.cc
│ │ ├── unicode-test.cc
│ │ ├── util.cc
│ │ ├── util.h
│ │ └── xchar-test.cc
│ ├── multiprecision-Boost_1_81_0/
│ │ ├── .circleci/
│ │ │ └── config.yml
│ │ ├── .clang-format
│ │ ├── .drone/
│ │ │ ├── after-success.sh
│ │ │ ├── before-install.sh
│ │ │ ├── before-script.sh
│ │ │ └── boost.sh
│ │ ├── .drone.star
│ │ ├── .gitattributes
│ │ ├── .github/
│ │ │ └── workflows/
│ │ │ └── multiprecision.yml
│ │ ├── .gitignore
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── config/
│ │ │ ├── Jamfile.v2
│ │ │ ├── has_big_obj.cpp
│ │ │ ├── has_constexpr_limits_cmd.cpp
│ │ │ ├── has_eigen.cpp
│ │ │ ├── has_f2c.cpp
│ │ │ ├── has_float128.cpp
│ │ │ ├── has_gmp.cpp
│ │ │ ├── has_intel_quad.cpp
│ │ │ ├── has_is_constant_evaluated.cpp
│ │ │ ├── has_mpc.cpp
│ │ │ ├── has_mpfi.cpp
│ │ │ ├── has_mpfr.cpp
│ │ │ ├── has_tommath.cpp
│ │ │ └── is_ci_sanitizer_run.cpp
│ │ ├── doc/
│ │ │ ├── Jamfile.v2
│ │ │ ├── floating_point_eg1.mml
│ │ │ ├── floating_point_eg2.mml
│ │ │ ├── floating_point_eg3.mml
│ │ │ ├── generate.sh
│ │ │ ├── history.qbk
│ │ │ ├── html/
│ │ │ │ ├── boost_multiprecision/
│ │ │ │ │ ├── indexes/
│ │ │ │ │ │ ├── s01.html
│ │ │ │ │ │ ├── s02.html
│ │ │ │ │ │ ├── s03.html
│ │ │ │ │ │ └── s04.html
│ │ │ │ │ ├── indexes.html
│ │ │ │ │ ├── intro.html
│ │ │ │ │ ├── map/
│ │ │ │ │ │ ├── ack.html
│ │ │ │ │ │ ├── faq.html
│ │ │ │ │ │ ├── hist.html
│ │ │ │ │ │ └── todo.html
│ │ │ │ │ ├── map.html
│ │ │ │ │ ├── perf/
│ │ │ │ │ │ ├── float_performance.html
│ │ │ │ │ │ ├── int_real_world.html
│ │ │ │ │ │ ├── integer_performance.html
│ │ │ │ │ │ ├── overhead.html
│ │ │ │ │ │ ├── rational_performance.html
│ │ │ │ │ │ ├── rational_real_world.html
│ │ │ │ │ │ └── realworld.html
│ │ │ │ │ ├── perf.html
│ │ │ │ │ ├── ref/
│ │ │ │ │ │ ├── backendconc.html
│ │ │ │ │ │ ├── cpp_bin_float_ref.html
│ │ │ │ │ │ ├── cpp_dec_ref.html
│ │ │ │ │ │ ├── cpp_int_ref.html
│ │ │ │ │ │ ├── gmp_int_ref.html
│ │ │ │ │ │ ├── headers.html
│ │ │ │ │ │ ├── internals.html
│ │ │ │ │ │ ├── mpf_ref.html
│ │ │ │ │ │ ├── mpfr_ref.html
│ │ │ │ │ │ ├── number.html
│ │ │ │ │ │ └── tom_int_ref.html
│ │ │ │ │ ├── ref.html
│ │ │ │ │ ├── tut/
│ │ │ │ │ │ ├── complex/
│ │ │ │ │ │ │ ├── complex128.html
│ │ │ │ │ │ │ ├── complex_adaptor.html
│ │ │ │ │ │ │ ├── cpp_complex.html
│ │ │ │ │ │ │ └── mpc_complex.html
│ │ │ │ │ │ ├── complex.html
│ │ │ │ │ │ ├── conversions.html
│ │ │ │ │ │ ├── eigen.html
│ │ │ │ │ │ ├── floats/
│ │ │ │ │ │ │ ├── cpp_bin_float.html
│ │ │ │ │ │ │ ├── cpp_dec_float.html
│ │ │ │ │ │ │ ├── float128.html
│ │ │ │ │ │ │ ├── fp_eg/
│ │ │ │ │ │ │ │ ├── aos.html
│ │ │ │ │ │ │ │ ├── caveats.html
│ │ │ │ │ │ │ │ ├── floatbuiltinctor.html
│ │ │ │ │ │ │ │ ├── gauss_lagerre_quadrature.html
│ │ │ │ │ │ │ │ ├── gi.html
│ │ │ │ │ │ │ │ ├── jel.html
│ │ │ │ │ │ │ │ ├── nd.html
│ │ │ │ │ │ │ │ ├── poly_eg.html
│ │ │ │ │ │ │ │ └── variable_precision.html
│ │ │ │ │ │ │ ├── fp_eg.html
│ │ │ │ │ │ │ ├── gmp_float.html
│ │ │ │ │ │ │ └── mpfr_float.html
│ │ │ │ │ │ ├── floats.html
│ │ │ │ │ │ ├── gen_int.html
│ │ │ │ │ │ ├── hash.html
│ │ │ │ │ │ ├── import_export.html
│ │ │ │ │ │ ├── input_output.html
│ │ │ │ │ │ ├── interval/
│ │ │ │ │ │ │ └── mpfi.html
│ │ │ │ │ │ ├── interval.html
│ │ │ │ │ │ ├── ints/
│ │ │ │ │ │ │ ├── cpp_int.html
│ │ │ │ │ │ │ ├── egs/
│ │ │ │ │ │ │ │ ├── bitops.html
│ │ │ │ │ │ │ │ └── factorials.html
│ │ │ │ │ │ │ ├── egs.html
│ │ │ │ │ │ │ ├── gmp_int.html
│ │ │ │ │ │ │ └── tom_int.html
│ │ │ │ │ │ ├── ints.html
│ │ │ │ │ │ ├── limits/
│ │ │ │ │ │ │ ├── constants.html
│ │ │ │ │ │ │ ├── functions.html
│ │ │ │ │ │ │ ├── how_to_tell.html
│ │ │ │ │ │ │ └── limits32.html
│ │ │ │ │ │ ├── limits.html
│ │ │ │ │ │ ├── lits.html
│ │ │ │ │ │ ├── misc/
│ │ │ │ │ │ │ ├── debug_adaptor.html
│ │ │ │ │ │ │ ├── logged_adaptor.html
│ │ │ │ │ │ │ └── visualizers.html
│ │ │ │ │ │ ├── misc.html
│ │ │ │ │ │ ├── mixed.html
│ │ │ │ │ │ ├── new_backend.html
│ │ │ │ │ │ ├── primetest.html
│ │ │ │ │ │ ├── random.html
│ │ │ │ │ │ ├── rational/
│ │ │ │ │ │ │ ├── cpp_rational.html
│ │ │ │ │ │ │ ├── gmp_rational.html
│ │ │ │ │ │ │ ├── rational_adaptor.html
│ │ │ │ │ │ │ ├── tommath_rational.html
│ │ │ │ │ │ │ └── tommath_rational0.html
│ │ │ │ │ │ ├── rational.html
│ │ │ │ │ │ ├── rounding.html
│ │ │ │ │ │ ├── serial.html
│ │ │ │ │ │ └── variable.html
│ │ │ │ │ └── tut.html
│ │ │ │ ├── index.html
│ │ │ │ └── multiprecision.css
│ │ │ ├── html4_symbols.qbk
│ │ │ ├── index.idx
│ │ │ ├── introduction.qbk
│ │ │ ├── multiprecision.css
│ │ │ ├── multiprecision.qbk
│ │ │ ├── numeric_limits_32_tables.qbk
│ │ │ ├── numeric_limits_qbk.cpp
│ │ │ ├── performance.qbk
│ │ │ ├── performance_float.qbk
│ │ │ ├── performance_integer.qbk
│ │ │ ├── performance_integer_real_world.qbk
│ │ │ ├── performance_overhead.qbk
│ │ │ ├── performance_rational.qbk
│ │ │ ├── performance_rational_real_world.qbk
│ │ │ ├── performance_real_world.qbk
│ │ │ ├── reference.qbk
│ │ │ ├── reference_backend_requirements.qbk
│ │ │ ├── reference_cpp_bin_float.qbk
│ │ │ ├── reference_cpp_dec_float.qbk
│ │ │ ├── reference_cpp_int.qbk
│ │ │ ├── reference_gmp_float.qbk
│ │ │ ├── reference_gmp_int.qbk
│ │ │ ├── reference_header_structure.qbk
│ │ │ ├── reference_internal_support.qbk
│ │ │ ├── reference_mpfr_float.qbk
│ │ │ ├── reference_number.qbk
│ │ │ ├── reference_tom_int.qbk
│ │ │ ├── tutorial.qbk
│ │ │ ├── tutorial_boost_rational.qbk
│ │ │ ├── tutorial_complex.qbk
│ │ │ ├── tutorial_complex_adaptor.qbk
│ │ │ ├── tutorial_constexpr.qbk
│ │ │ ├── tutorial_conversions.qbk
│ │ │ ├── tutorial_cpp_bin_float.qbk
│ │ │ ├── tutorial_cpp_complex.qbk
│ │ │ ├── tutorial_cpp_dec_float.qbk
│ │ │ ├── tutorial_cpp_int.qbk
│ │ │ ├── tutorial_cpp_rational.qbk
│ │ │ ├── tutorial_debug_adaptor.qbk
│ │ │ ├── tutorial_eigen.qbk
│ │ │ ├── tutorial_float128.qbk
│ │ │ ├── tutorial_float128_complex.qbk
│ │ │ ├── tutorial_float_builtin_ctor.qbk
│ │ │ ├── tutorial_float_eg.qbk
│ │ │ ├── tutorial_floats.qbk
│ │ │ ├── tutorial_gmp_float.qbk
│ │ │ ├── tutorial_gmp_int.qbk
│ │ │ ├── tutorial_gmp_rational.qbk
│ │ │ ├── tutorial_hash.qbk
│ │ │ ├── tutorial_import_export.qbk
│ │ │ ├── tutorial_integer.qbk
│ │ │ ├── tutorial_integer_examples.qbk
│ │ │ ├── tutorial_integer_ops.qbk
│ │ │ ├── tutorial_interval_mpfi.qbk
│ │ │ ├── tutorial_io.qbk
│ │ │ ├── tutorial_logged_adaptor.qbk
│ │ │ ├── tutorial_misc_backends.qbk
│ │ │ ├── tutorial_mixed_precision.qbk
│ │ │ ├── tutorial_mpc_complex.qbk
│ │ │ ├── tutorial_mpfr_float.qbk
│ │ │ ├── tutorial_new_backend.qbk
│ │ │ ├── tutorial_numeric_limits.qbk
│ │ │ ├── tutorial_primality.qbk
│ │ │ ├── tutorial_random.qbk
│ │ │ ├── tutorial_rational.qbk
│ │ │ ├── tutorial_rational_adaptor.qbk
│ │ │ ├── tutorial_rounding.qbk
│ │ │ ├── tutorial_serialization.qbk
│ │ │ ├── tutorial_tommath.qbk
│ │ │ ├── tutorial_tommath_rational.qbk
│ │ │ ├── tutorial_variable_precision.qbk
│ │ │ └── tutorial_visualizers.qbk
│ │ ├── example/
│ │ │ ├── Jamfile.v2
│ │ │ ├── big_seventh.cpp
│ │ │ ├── complex128_examples.cpp
│ │ │ ├── constexpr_float_arithmetic_examples.cpp
│ │ │ ├── cpp_bin_float_import_export.cpp
│ │ │ ├── cpp_bin_float_snips.cpp
│ │ │ ├── cpp_complex_examples.cpp
│ │ │ ├── cpp_dec_float_snips.cpp
│ │ │ ├── cpp_int_import_export.cpp
│ │ │ ├── cpp_int_mul_timing.cpp
│ │ │ ├── cpp_int_snips.cpp
│ │ │ ├── debug_adaptor_snips.cpp
│ │ │ ├── eigen_example.cpp
│ │ │ ├── exercise_threading_log_agm.cpp
│ │ │ ├── float128_snips.cpp
│ │ │ ├── floating_point_examples.cpp
│ │ │ ├── gauss_laguerre_quadrature.cpp
│ │ │ ├── gmp_snips.cpp
│ │ │ ├── hashing_examples.cpp
│ │ │ ├── hypergeometric_luke_algorithms.cpp
│ │ │ ├── integer_examples.cpp
│ │ │ ├── logged_adaptor.cpp
│ │ │ ├── mixed_integer_arithmetic.cpp
│ │ │ ├── mpc_examples.cpp
│ │ │ ├── mpfi_snips.cpp
│ │ │ ├── mpfr_precision.cpp
│ │ │ ├── mpfr_snips.cpp
│ │ │ ├── numeric_limits_snips.cpp
│ │ │ ├── random_snips.cpp
│ │ │ ├── safe_prime.cpp
│ │ │ ├── scoped_precision_example.cpp
│ │ │ ├── standalone_bernoulli_tgamma.cpp
│ │ │ └── tommath_snips.cpp
│ │ ├── include/
│ │ │ └── boost/
│ │ │ ├── config/
│ │ │ │ ├── abi/
│ │ │ │ │ ├── borland_prefix.hpp
│ │ │ │ │ ├── borland_suffix.hpp
│ │ │ │ │ ├── msvc_prefix.hpp
│ │ │ │ │ └── msvc_suffix.hpp
│ │ │ │ ├── abi_prefix.hpp
│ │ │ │ ├── abi_suffix.hpp
│ │ │ │ ├── assert_cxx03.hpp
│ │ │ │ ├── assert_cxx11.hpp
│ │ │ │ ├── assert_cxx14.hpp
│ │ │ │ ├── assert_cxx17.hpp
│ │ │ │ ├── assert_cxx20.hpp
│ │ │ │ ├── assert_cxx98.hpp
│ │ │ │ ├── auto_link.hpp
│ │ │ │ ├── compiler/
│ │ │ │ │ ├── borland.hpp
│ │ │ │ │ ├── clang.hpp
│ │ │ │ │ ├── clang_version.hpp
│ │ │ │ │ ├── codegear.hpp
│ │ │ │ │ ├── comeau.hpp
│ │ │ │ │ ├── common_edg.hpp
│ │ │ │ │ ├── compaq_cxx.hpp
│ │ │ │ │ ├── cray.hpp
│ │ │ │ │ ├── diab.hpp
│ │ │ │ │ ├── digitalmars.hpp
│ │ │ │ │ ├── gcc.hpp
│ │ │ │ │ ├── gcc_xml.hpp
│ │ │ │ │ ├── greenhills.hpp
│ │ │ │ │ ├── hp_acc.hpp
│ │ │ │ │ ├── intel.hpp
│ │ │ │ │ ├── kai.hpp
│ │ │ │ │ ├── metrowerks.hpp
│ │ │ │ │ ├── mpw.hpp
│ │ │ │ │ ├── nvcc.hpp
│ │ │ │ │ ├── pathscale.hpp
│ │ │ │ │ ├── pgi.hpp
│ │ │ │ │ ├── sgi_mipspro.hpp
│ │ │ │ │ ├── sunpro_cc.hpp
│ │ │ │ │ ├── vacpp.hpp
│ │ │ │ │ ├── visualc.hpp
│ │ │ │ │ ├── xlcpp.hpp
│ │ │ │ │ └── xlcpp_zos.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── cxx_composite.hpp
│ │ │ │ │ ├── posix_features.hpp
│ │ │ │ │ ├── select_compiler_config.hpp
│ │ │ │ │ ├── select_platform_config.hpp
│ │ │ │ │ ├── select_stdlib_config.hpp
│ │ │ │ │ └── suffix.hpp
│ │ │ │ ├── header_deprecated.hpp
│ │ │ │ ├── helper_macros.hpp
│ │ │ │ ├── no_tr1/
│ │ │ │ │ ├── cmath.hpp
│ │ │ │ │ ├── complex.hpp
│ │ │ │ │ ├── functional.hpp
│ │ │ │ │ ├── memory.hpp
│ │ │ │ │ └── utility.hpp
│ │ │ │ ├── platform/
│ │ │ │ │ ├── aix.hpp
│ │ │ │ │ ├── amigaos.hpp
│ │ │ │ │ ├── beos.hpp
│ │ │ │ │ ├── bsd.hpp
│ │ │ │ │ ├── cloudabi.hpp
│ │ │ │ │ ├── cray.hpp
│ │ │ │ │ ├── cygwin.hpp
│ │ │ │ │ ├── haiku.hpp
│ │ │ │ │ ├── hpux.hpp
│ │ │ │ │ ├── irix.hpp
│ │ │ │ │ ├── linux.hpp
│ │ │ │ │ ├── macos.hpp
│ │ │ │ │ ├── qnxnto.hpp
│ │ │ │ │ ├── solaris.hpp
│ │ │ │ │ ├── symbian.hpp
│ │ │ │ │ ├── vms.hpp
│ │ │ │ │ ├── vxworks.hpp
│ │ │ │ │ ├── wasm.hpp
│ │ │ │ │ ├── win32.hpp
│ │ │ │ │ └── zos.hpp
│ │ │ │ ├── pragma_message.hpp
│ │ │ │ ├── requires_threads.hpp
│ │ │ │ ├── stdlib/
│ │ │ │ │ ├── dinkumware.hpp
│ │ │ │ │ ├── libcomo.hpp
│ │ │ │ │ ├── libcpp.hpp
│ │ │ │ │ ├── libstdcpp3.hpp
│ │ │ │ │ ├── modena.hpp
│ │ │ │ │ ├── msl.hpp
│ │ │ │ │ ├── roguewave.hpp
│ │ │ │ │ ├── sgi.hpp
│ │ │ │ │ ├── stlport.hpp
│ │ │ │ │ ├── vacpp.hpp
│ │ │ │ │ └── xlcpp_zos.hpp
│ │ │ │ ├── user.hpp
│ │ │ │ ├── warning_disable.hpp
│ │ │ │ └── workaround.hpp
│ │ │ ├── config.hpp
│ │ │ ├── cstdint.hpp
│ │ │ ├── cxx11_char_types.hpp
│ │ │ ├── detail/
│ │ │ │ └── workaround.hpp
│ │ │ ├── limits.hpp
│ │ │ ├── multiprecision/
│ │ │ │ ├── complex128.hpp
│ │ │ │ ├── complex_adaptor.hpp
│ │ │ │ ├── concepts/
│ │ │ │ │ └── mp_number_archetypes.hpp
│ │ │ │ ├── cpp_bin_float/
│ │ │ │ │ ├── io.hpp
│ │ │ │ │ └── transcendental.hpp
│ │ │ │ ├── cpp_bin_float.hpp
│ │ │ │ ├── cpp_complex.hpp
│ │ │ │ ├── cpp_dec_float.hpp
│ │ │ │ ├── cpp_int/
│ │ │ │ │ ├── add.hpp
│ │ │ │ │ ├── add_unsigned.hpp
│ │ │ │ │ ├── bitwise.hpp
│ │ │ │ │ ├── checked.hpp
│ │ │ │ │ ├── comparison.hpp
│ │ │ │ │ ├── cpp_int_config.hpp
│ │ │ │ │ ├── divide.hpp
│ │ │ │ │ ├── import_export.hpp
│ │ │ │ │ ├── intel_intrinsics.hpp
│ │ │ │ │ ├── limits.hpp
│ │ │ │ │ ├── literals.hpp
│ │ │ │ │ ├── misc.hpp
│ │ │ │ │ ├── multiply.hpp
│ │ │ │ │ ├── serialize.hpp
│ │ │ │ │ └── value_pack.hpp
│ │ │ │ ├── cpp_int.hpp
│ │ │ │ ├── debug_adaptor.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── assert.hpp
│ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ ├── bitscan.hpp
│ │ │ │ │ ├── check_cpp11_config.hpp
│ │ │ │ │ ├── constexpr.hpp
│ │ │ │ │ ├── default_ops.hpp
│ │ │ │ │ ├── digits.hpp
│ │ │ │ │ ├── dynamic_array.hpp
│ │ │ │ │ ├── empty_value.hpp
│ │ │ │ │ ├── endian.hpp
│ │ │ │ │ ├── et_ops.hpp
│ │ │ │ │ ├── float128_functions.hpp
│ │ │ │ │ ├── float_string_cvt.hpp
│ │ │ │ │ ├── fpclassify.hpp
│ │ │ │ │ ├── functions/
│ │ │ │ │ │ ├── constants.hpp
│ │ │ │ │ │ ├── pow.hpp
│ │ │ │ │ │ ├── trig.hpp
│ │ │ │ │ │ └── trunc.hpp
│ │ │ │ │ ├── generic_interconvert.hpp
│ │ │ │ │ ├── hash.hpp
│ │ │ │ │ ├── integer_ops.hpp
│ │ │ │ │ ├── itos.hpp
│ │ │ │ │ ├── min_max.hpp
│ │ │ │ │ ├── no_et_ops.hpp
│ │ │ │ │ ├── no_exceptions_support.hpp
│ │ │ │ │ ├── number_base.hpp
│ │ │ │ │ ├── number_compare.hpp
│ │ │ │ │ ├── precision.hpp
│ │ │ │ │ ├── rebind.hpp
│ │ │ │ │ ├── standalone_config.hpp
│ │ │ │ │ ├── static_array.hpp
│ │ │ │ │ ├── tables.hpp
│ │ │ │ │ ├── ublas_interop.hpp
│ │ │ │ │ ├── uniform_int_distribution.hpp
│ │ │ │ │ └── utype_helper.hpp
│ │ │ │ ├── eigen.hpp
│ │ │ │ ├── float128.hpp
│ │ │ │ ├── gmp.hpp
│ │ │ │ ├── integer.hpp
│ │ │ │ ├── logged_adaptor.hpp
│ │ │ │ ├── miller_rabin.hpp
│ │ │ │ ├── mpc.hpp
│ │ │ │ ├── mpfi.hpp
│ │ │ │ ├── mpfr.hpp
│ │ │ │ ├── number.hpp
│ │ │ │ ├── random.hpp
│ │ │ │ ├── rational_adaptor.hpp
│ │ │ │ ├── tommath.hpp
│ │ │ │ └── traits/
│ │ │ │ ├── explicit_conversion.hpp
│ │ │ │ ├── extract_exponent_type.hpp
│ │ │ │ ├── is_backend.hpp
│ │ │ │ ├── is_byte_container.hpp
│ │ │ │ ├── is_complex.hpp
│ │ │ │ ├── is_convertible_arithmetic.hpp
│ │ │ │ ├── is_restricted_conversion.hpp
│ │ │ │ ├── is_variable_precision.hpp
│ │ │ │ ├── max_digits10.hpp
│ │ │ │ ├── std_integer_traits.hpp
│ │ │ │ └── transcendental_reduction_type.hpp
│ │ │ └── version.hpp
│ │ ├── index.html
│ │ ├── meta/
│ │ │ └── libraries.json
│ │ ├── performance/
│ │ │ ├── Jamfile.v2
│ │ │ ├── arithmetic_backend.hpp
│ │ │ ├── cpp_bin_float_conversion_performance.cpp
│ │ │ ├── delaunay_test.cpp
│ │ │ ├── delaunay_test.log
│ │ │ ├── gcd_bench.cpp
│ │ │ ├── linpack-benchmark.cpp
│ │ │ ├── miller_rabin_performance.cpp
│ │ │ ├── miller_rabin_performance.hpp
│ │ │ ├── miller_rabin_performance.log
│ │ │ ├── miller_rabin_performance_files/
│ │ │ │ ├── test01.cpp
│ │ │ │ ├── test02.cpp
│ │ │ │ ├── test03.cpp
│ │ │ │ ├── test04.cpp
│ │ │ │ ├── test05.cpp
│ │ │ │ ├── test06.cpp
│ │ │ │ ├── test07.cpp
│ │ │ │ ├── test08.cpp
│ │ │ │ ├── test09.cpp
│ │ │ │ ├── test10.cpp
│ │ │ │ ├── test11.cpp
│ │ │ │ └── test12.cpp
│ │ │ ├── mixed_equivalent_types_bench.cpp
│ │ │ ├── performance_test-gcc-linux.log
│ │ │ ├── performance_test-intel-linux.log
│ │ │ ├── performance_test-msvc-10.log
│ │ │ ├── performance_test.cpp
│ │ │ ├── performance_test.hpp
│ │ │ ├── performance_test.log
│ │ │ ├── performance_test_files/
│ │ │ │ ├── test01.cpp
│ │ │ │ ├── test02.cpp
│ │ │ │ ├── test03.cpp
│ │ │ │ ├── test04.cpp
│ │ │ │ ├── test05.cpp
│ │ │ │ ├── test06.cpp
│ │ │ │ ├── test07.cpp
│ │ │ │ ├── test08.cpp
│ │ │ │ ├── test09.cpp
│ │ │ │ ├── test10.cpp
│ │ │ │ ├── test11.cpp
│ │ │ │ ├── test12.cpp
│ │ │ │ ├── test13.cpp
│ │ │ │ ├── test14.cpp
│ │ │ │ ├── test15.cpp
│ │ │ │ ├── test16.cpp
│ │ │ │ ├── test17.cpp
│ │ │ │ ├── test18.cpp
│ │ │ │ ├── test19.cpp
│ │ │ │ ├── test20.cpp
│ │ │ │ ├── test21.cpp
│ │ │ │ ├── test22.cpp
│ │ │ │ ├── test23.cpp
│ │ │ │ ├── test24.cpp
│ │ │ │ ├── test25.cpp
│ │ │ │ ├── test26.cpp
│ │ │ │ ├── test27.cpp
│ │ │ │ ├── test28.cpp
│ │ │ │ ├── test29.cpp
│ │ │ │ ├── test30.cpp
│ │ │ │ ├── test31.cpp
│ │ │ │ ├── test32.cpp
│ │ │ │ ├── test33.cpp
│ │ │ │ ├── test34.cpp
│ │ │ │ ├── test35.cpp
│ │ │ │ ├── test36.cpp
│ │ │ │ ├── test37.cpp
│ │ │ │ ├── test38.cpp
│ │ │ │ ├── test39.cpp
│ │ │ │ ├── test40.cpp
│ │ │ │ ├── test41.cpp
│ │ │ │ ├── test42.cpp
│ │ │ │ ├── test43.cpp
│ │ │ │ ├── test44.cpp
│ │ │ │ ├── test45.cpp
│ │ │ │ ├── test46.cpp
│ │ │ │ ├── test47.cpp
│ │ │ │ ├── test48.cpp
│ │ │ │ ├── test49.cpp
│ │ │ │ ├── test50.cpp
│ │ │ │ └── test51.cpp
│ │ │ ├── rational_bernoulli_allocations.cpp
│ │ │ ├── rational_bernoulli_allocations.log
│ │ │ ├── rational_bernoulli_bench.cpp
│ │ │ ├── rational_bernoulli_bench.log
│ │ │ ├── rational_determinant_bench.cpp
│ │ │ ├── rational_determinant_bench.log
│ │ │ ├── rational_zeta18_bench.cpp
│ │ │ ├── sf_performance-msvc-10.log
│ │ │ ├── sf_performance.cpp
│ │ │ ├── sf_performance.hpp
│ │ │ ├── sf_performance.log
│ │ │ ├── sf_performance_basic.cpp
│ │ │ ├── sf_performance_bessel.cpp
│ │ │ ├── sf_performance_files/
│ │ │ │ ├── sf_performance_basic_1.cpp
│ │ │ │ ├── sf_performance_basic_2.cpp
│ │ │ │ ├── sf_performance_basic_3.cpp
│ │ │ │ ├── sf_performance_basic_4.cpp
│ │ │ │ ├── sf_performance_basic_5.cpp
│ │ │ │ ├── sf_performance_basic_6.cpp
│ │ │ │ ├── sf_performance_basic_7.cpp
│ │ │ │ ├── sf_performance_basic_8.cpp
│ │ │ │ ├── sf_performance_basic_9.cpp
│ │ │ │ ├── sf_performance_bessel_01.cpp
│ │ │ │ ├── sf_performance_bessel_02.cpp
│ │ │ │ ├── sf_performance_bessel_03.cpp
│ │ │ │ ├── sf_performance_bessel_04.cpp
│ │ │ │ ├── sf_performance_bessel_05.cpp
│ │ │ │ ├── sf_performance_bessel_06.cpp
│ │ │ │ ├── sf_performance_bessel_07.cpp
│ │ │ │ ├── sf_performance_bessel_08.cpp
│ │ │ │ ├── sf_performance_bessel_09.cpp
│ │ │ │ ├── sf_performance_bessel_10.cpp
│ │ │ │ ├── sf_performance_bessel_11.cpp
│ │ │ │ ├── sf_performance_bessel_12.cpp
│ │ │ │ ├── sf_performance_bessel_13.cpp
│ │ │ │ ├── sf_performance_bessel_14.cpp
│ │ │ │ ├── sf_performance_bessel_15.cpp
│ │ │ │ ├── sf_performance_bessel_16.cpp
│ │ │ │ ├── sf_performance_bessel_17.cpp
│ │ │ │ ├── sf_performance_bessel_18.cpp
│ │ │ │ ├── sf_performance_bessel_19.cpp
│ │ │ │ ├── sf_performance_nct_01.cpp
│ │ │ │ ├── sf_performance_nct_02.cpp
│ │ │ │ ├── sf_performance_nct_03.cpp
│ │ │ │ ├── sf_performance_nct_04.cpp
│ │ │ │ ├── sf_performance_nct_05.cpp
│ │ │ │ ├── sf_performance_nct_06.cpp
│ │ │ │ ├── sf_performance_nct_07.cpp
│ │ │ │ ├── sf_performance_nct_08.cpp
│ │ │ │ ├── sf_performance_nct_09.cpp
│ │ │ │ ├── sf_performance_nct_10.cpp
│ │ │ │ ├── sf_performance_nct_11.cpp
│ │ │ │ ├── sf_performance_nct_12.cpp
│ │ │ │ ├── sf_performance_nct_13.cpp
│ │ │ │ ├── sf_performance_nct_14.cpp
│ │ │ │ ├── sf_performance_nct_15.cpp
│ │ │ │ ├── sf_performance_nct_16.cpp
│ │ │ │ ├── sf_performance_nct_17.cpp
│ │ │ │ ├── sf_performance_nct_18.cpp
│ │ │ │ ├── sf_performance_nct_19.cpp
│ │ │ │ ├── sf_performance_nct_20.cpp
│ │ │ │ ├── sf_performance_poly_01.cpp
│ │ │ │ ├── sf_performance_poly_02.cpp
│ │ │ │ ├── sf_performance_poly_03.cpp
│ │ │ │ ├── sf_performance_poly_04.cpp
│ │ │ │ ├── sf_performance_poly_05.cpp
│ │ │ │ ├── sf_performance_poly_06.cpp
│ │ │ │ ├── sf_performance_poly_07.cpp
│ │ │ │ ├── sf_performance_poly_08.cpp
│ │ │ │ ├── sf_performance_poly_09.cpp
│ │ │ │ ├── sf_performance_poly_10.cpp
│ │ │ │ ├── sf_performance_poly_11.cpp
│ │ │ │ ├── sf_performance_poly_12.cpp
│ │ │ │ ├── sf_performance_poly_13.cpp
│ │ │ │ ├── sf_performance_poly_14.cpp
│ │ │ │ ├── sf_performance_poly_15.cpp
│ │ │ │ ├── sf_performance_poly_16.cpp
│ │ │ │ ├── sf_performance_poly_17.cpp
│ │ │ │ └── sf_performance_poly_18.cpp
│ │ │ ├── sf_performance_nct.cpp
│ │ │ ├── sf_performance_poly.cpp
│ │ │ ├── sqrt_bench.cpp
│ │ │ ├── veronoi_performance.log
│ │ │ └── voronoi_performance.cpp
│ │ ├── plots/
│ │ │ ├── cpp_bin_float_acos_errors.cpp
│ │ │ ├── cpp_bin_float_asin_errors.cpp
│ │ │ ├── cpp_bin_float_atan_errors.cpp
│ │ │ ├── cpp_bin_float_cos_errors.cpp
│ │ │ ├── cpp_bin_float_erf_errors.cpp
│ │ │ ├── cpp_bin_float_erfc_errors.cpp
│ │ │ ├── cpp_bin_float_exp_errors.cpp
│ │ │ ├── cpp_bin_float_log_errors.cpp
│ │ │ ├── cpp_bin_float_sin_errors.cpp
│ │ │ ├── cpp_bin_float_tan_errors.cpp
│ │ │ └── cpp_bin_float_tgamma_errors.cpp
│ │ ├── test/
│ │ │ ├── Jamfile.v2
│ │ │ ├── bug11922.cpp
│ │ │ ├── bug12039.cpp
│ │ │ ├── compile_fail/
│ │ │ │ ├── conv_fail_01.cpp
│ │ │ │ ├── conv_fail_02.cpp
│ │ │ │ ├── conv_fail_03.cpp
│ │ │ │ ├── conv_fail_04.cpp
│ │ │ │ ├── conv_fail_05.cpp
│ │ │ │ ├── conv_fail_06.cpp
│ │ │ │ ├── conv_fail_07.cpp
│ │ │ │ ├── conv_fail_08.cpp
│ │ │ │ ├── conv_fail_09.cpp
│ │ │ │ ├── conv_fail_10.cpp
│ │ │ │ ├── conv_fail_11.cpp
│ │ │ │ ├── conv_fail_12.cpp
│ │ │ │ ├── conv_fail_13.cpp
│ │ │ │ ├── conv_fail_14.cpp
│ │ │ │ ├── conv_fail_15.cpp
│ │ │ │ ├── conv_fail_16.cpp
│ │ │ │ ├── conv_fail_18.cpp
│ │ │ │ ├── conv_fail_20.cpp
│ │ │ │ ├── conv_fail_21.cpp
│ │ │ │ ├── conv_fail_22.cpp
│ │ │ │ ├── conv_fail_23.cpp
│ │ │ │ ├── conv_fail_24.cpp
│ │ │ │ ├── conv_fail_25.cpp
│ │ │ │ ├── conv_fail_26.cpp
│ │ │ │ ├── conv_fail_27.cpp
│ │ │ │ ├── conv_fail_28.cpp
│ │ │ │ ├── conv_fail_29.cpp
│ │ │ │ ├── conv_fail_30.cpp
│ │ │ │ ├── conv_fail_31.cpp
│ │ │ │ ├── conv_fail_32.cpp
│ │ │ │ ├── conv_fail_33.cpp
│ │ │ │ ├── conv_fail_34.cpp
│ │ │ │ ├── conv_fail_35.cpp
│ │ │ │ ├── conv_fail_36.cpp
│ │ │ │ ├── conv_fail_37.cpp
│ │ │ │ ├── conv_fail_38.cpp
│ │ │ │ ├── conv_fail_39.cpp
│ │ │ │ ├── conv_fail_40.cpp
│ │ │ │ ├── conv_fail_41.cpp
│ │ │ │ ├── conv_fail_42.cpp
│ │ │ │ ├── conv_fail_43.cpp
│ │ │ │ ├── conv_fail_44.cpp
│ │ │ │ ├── conv_fail_45.cpp
│ │ │ │ ├── conv_fail_46.cpp
│ │ │ │ ├── conv_fail_47.cpp
│ │ │ │ ├── conv_fail_48.cpp
│ │ │ │ ├── conv_fail_49.cpp
│ │ │ │ ├── conv_fail_50.cpp
│ │ │ │ ├── conv_fail_51.cpp
│ │ │ │ ├── conv_fail_52.cpp
│ │ │ │ ├── conv_fail_53.cpp
│ │ │ │ ├── conv_fail_54.cpp
│ │ │ │ ├── conv_fail_55.cpp
│ │ │ │ ├── conv_fail_56.cpp
│ │ │ │ ├── conv_fail_57.cpp
│ │ │ │ ├── conv_fail_58.cpp
│ │ │ │ ├── conv_fail_59.cpp
│ │ │ │ ├── cpp_int_complement.cpp
│ │ │ │ ├── cpp_int_negate_1.cpp
│ │ │ │ ├── cpp_int_negate_2.cpp
│ │ │ │ ├── operator_fail_01.cpp
│ │ │ │ ├── operator_fail_02.cpp
│ │ │ │ ├── operator_fail_03.cpp
│ │ │ │ ├── operator_fail_04.cpp
│ │ │ │ ├── operator_fail_05.cpp
│ │ │ │ ├── operator_fail_06.cpp
│ │ │ │ ├── operator_fail_07.cpp
│ │ │ │ ├── operator_fail_08.cpp
│ │ │ │ ├── operator_fail_09.cpp
│ │ │ │ ├── operator_fail_10.cpp
│ │ │ │ ├── operator_fail_11.cpp
│ │ │ │ ├── operator_fail_12.cpp
│ │ │ │ ├── operator_fail_13.cpp
│ │ │ │ ├── operator_fail_14.cpp
│ │ │ │ ├── operator_fail_15.cpp
│ │ │ │ ├── operator_fail_16.cpp
│ │ │ │ ├── operator_fail_17.cpp
│ │ │ │ └── operator_fail_18.cpp
│ │ │ ├── concepts/
│ │ │ │ ├── number_concept_check.cpp
│ │ │ │ ├── sf_concept_check_basic.cpp
│ │ │ │ ├── sf_concept_check_bessel.cpp
│ │ │ │ ├── sf_concept_check_beta.cpp
│ │ │ │ ├── sf_concept_check_beta_2.cpp
│ │ │ │ ├── sf_concept_check_beta_3.cpp
│ │ │ │ ├── sf_concept_check_elliptic.cpp
│ │ │ │ ├── sf_concept_check_gamma.cpp
│ │ │ │ └── sf_concept_check_poly.cpp
│ │ │ ├── constexpr_arithmetric_test.hpp
│ │ │ ├── constexpr_test_arithmetic_backend.cpp
│ │ │ ├── constexpr_test_cpp_int.cpp
│ │ │ ├── constexpr_test_cpp_int_2.cpp
│ │ │ ├── constexpr_test_cpp_int_3.cpp
│ │ │ ├── constexpr_test_cpp_int_4.cpp
│ │ │ ├── constexpr_test_cpp_int_5.cpp
│ │ │ ├── constexpr_test_cpp_int_6.cpp
│ │ │ ├── constexpr_test_cpp_int_7.cpp
│ │ │ ├── constexpr_test_float128.cpp
│ │ │ ├── eigen.hpp
│ │ │ ├── git_issue_167.cpp
│ │ │ ├── git_issue_175.cpp
│ │ │ ├── git_issue_248.cpp
│ │ │ ├── git_issue_265.cpp
│ │ │ ├── git_issue_277.cpp
│ │ │ ├── git_issue_30.cpp
│ │ │ ├── git_issue_313.cpp
│ │ │ ├── git_issue_370.cpp
│ │ │ ├── git_issue_393.cpp
│ │ │ ├── git_issue_426.cpp
│ │ │ ├── git_issue_464.cpp
│ │ │ ├── git_issue_488.cpp
│ │ │ ├── git_issue_98.cpp
│ │ │ ├── include_test/
│ │ │ │ ├── cpp_bin_float_include_test.cpp
│ │ │ │ ├── cpp_dec_float_include_test.cpp
│ │ │ │ ├── cpp_int_include_test.cpp
│ │ │ │ ├── gmp_include_test.cpp
│ │ │ │ ├── mpfr_include_test.cpp
│ │ │ │ └── tommath_include_test.cpp
│ │ │ ├── issue_13148.cpp
│ │ │ ├── issue_13301.cpp
│ │ │ ├── math/
│ │ │ │ ├── high_prec/
│ │ │ │ │ ├── gamma.ipp
│ │ │ │ │ ├── gamma_0.ipp
│ │ │ │ │ ├── gamma_1_2.ipp
│ │ │ │ │ ├── gamma_neg.ipp
│ │ │ │ │ ├── readme.txt
│ │ │ │ │ ├── test_gamma.cpp
│ │ │ │ │ └── test_gamma.hpp
│ │ │ │ ├── instances/
│ │ │ │ │ ├── Jamfile.v2
│ │ │ │ │ └── instances.cpp
│ │ │ │ ├── log1p_expm1_test.cpp
│ │ │ │ ├── powm1_sqrtp1m1_test.cpp
│ │ │ │ ├── readme.txt
│ │ │ │ ├── setup.hpp
│ │ │ │ ├── table_type.hpp
│ │ │ │ ├── test_bessel_i.cpp
│ │ │ │ ├── test_bessel_j.cpp
│ │ │ │ ├── test_bessel_k.cpp
│ │ │ │ ├── test_bessel_y.cpp
│ │ │ │ ├── test_beta.cpp
│ │ │ │ ├── test_binomial_coeff.cpp
│ │ │ │ ├── test_carlson_1.cpp
│ │ │ │ ├── test_carlson_2.cpp
│ │ │ │ ├── test_carlson_3.cpp
│ │ │ │ ├── test_carlson_4.cpp
│ │ │ │ ├── test_cbrt.cpp
│ │ │ │ ├── test_digamma.cpp
│ │ │ │ ├── test_ellint_1.cpp
│ │ │ │ ├── test_ellint_2.cpp
│ │ │ │ ├── test_ellint_3.cpp
│ │ │ │ ├── test_erf.cpp
│ │ │ │ ├── test_expint.cpp
│ │ │ │ ├── test_gamma.cpp
│ │ │ │ ├── test_hermite.cpp
│ │ │ │ ├── test_ibeta.cpp
│ │ │ │ ├── test_ibeta_2.cpp
│ │ │ │ ├── test_ibeta_3.cpp
│ │ │ │ ├── test_ibeta_4.cpp
│ │ │ │ ├── test_ibeta_inv_1.cpp
│ │ │ │ ├── test_ibeta_inv_ab_4.cpp
│ │ │ │ ├── test_igamma.cpp
│ │ │ │ ├── test_igamma_inv.cpp
│ │ │ │ ├── test_igamma_inva.cpp
│ │ │ │ ├── test_laguerre.cpp
│ │ │ │ ├── test_legendre.cpp
│ │ │ │ ├── test_tgamma_ratio.cpp
│ │ │ │ └── test_zeta.cpp
│ │ │ ├── no_eh_test_support.cpp
│ │ │ ├── serial_txts/
│ │ │ │ ├── boost-no-inspect
│ │ │ │ ├── cpp_int1024_serial32.txt
│ │ │ │ ├── cpp_int1024_serial64.txt
│ │ │ │ ├── cpp_int128_serial32.txt
│ │ │ │ ├── cpp_int128_serial64.txt
│ │ │ │ ├── cpp_int64_serial32.txt
│ │ │ │ └── cpp_int64_serial64.txt
│ │ │ ├── sincos.ipp
│ │ │ ├── skeleton_backend.hpp
│ │ │ ├── standalone_constexpr_test_cpp_int.cpp
│ │ │ ├── standalone_constexpr_test_float128.cpp
│ │ │ ├── standalone_test_arithmetic_complex128.cpp
│ │ │ ├── standalone_test_arithmetic_cpp_bin_float.cpp
│ │ │ ├── standalone_test_arithmetic_cpp_dec_float.cpp
│ │ │ ├── standalone_test_arithmetic_cpp_int.cpp
│ │ │ ├── standalone_test_arithmetic_cpp_rational.cpp
│ │ │ ├── standalone_test_arithmetic_float_128.cpp
│ │ │ ├── standalone_test_arithmetic_gmp.cpp
│ │ │ ├── standalone_test_arithmetic_int512.cpp
│ │ │ ├── standalone_test_arithmetic_mpf_logged_adptr.cpp
│ │ │ ├── standalone_test_arithmetic_mpz_rat.cpp
│ │ │ ├── standalone_test_arithmetic_tommath.cpp
│ │ │ ├── standalone_test_convert_from_tom_int.cpp
│ │ │ ├── standalone_test_miller_rabin.cpp
│ │ │ ├── string_data.ipp
│ │ │ ├── test.hpp
│ │ │ ├── test_acos.cpp
│ │ │ ├── test_adapt_serial.cpp
│ │ │ ├── test_arithmetic.hpp
│ │ │ ├── test_arithmetic_ab_1.cpp
│ │ │ ├── test_arithmetic_ab_2.cpp
│ │ │ ├── test_arithmetic_ab_3.cpp
│ │ │ ├── test_arithmetic_backend_concept.cpp
│ │ │ ├── test_arithmetic_complex128.cpp
│ │ │ ├── test_arithmetic_complex_adaptor.cpp
│ │ │ ├── test_arithmetic_complex_adaptor_2.cpp
│ │ │ ├── test_arithmetic_cpp_bin_float_1.cpp
│ │ │ ├── test_arithmetic_cpp_bin_float_2.cpp
│ │ │ ├── test_arithmetic_cpp_bin_float_2m.cpp
│ │ │ ├── test_arithmetic_cpp_bin_float_3.cpp
│ │ │ ├── test_arithmetic_cpp_bin_float_4.cpp
│ │ │ ├── test_arithmetic_cpp_bin_float_5.cpp
│ │ │ ├── test_arithmetic_cpp_complex_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_cpp_complex_logged_adptr.cpp
│ │ │ ├── test_arithmetic_cpp_dec_float_1.cpp
│ │ │ ├── test_arithmetic_cpp_dec_float_2.cpp
│ │ │ ├── test_arithmetic_cpp_dec_float_3.cpp
│ │ │ ├── test_arithmetic_cpp_dec_float_3m.cpp
│ │ │ ├── test_arithmetic_cpp_int_1.cpp
│ │ │ ├── test_arithmetic_cpp_int_10.cpp
│ │ │ ├── test_arithmetic_cpp_int_11.cpp
│ │ │ ├── test_arithmetic_cpp_int_12.cpp
│ │ │ ├── test_arithmetic_cpp_int_13.cpp
│ │ │ ├── test_arithmetic_cpp_int_14.cpp
│ │ │ ├── test_arithmetic_cpp_int_15.cpp
│ │ │ ├── test_arithmetic_cpp_int_16.cpp
│ │ │ ├── test_arithmetic_cpp_int_17.cpp
│ │ │ ├── test_arithmetic_cpp_int_18.cpp
│ │ │ ├── test_arithmetic_cpp_int_19.cpp
│ │ │ ├── test_arithmetic_cpp_int_2.cpp
│ │ │ ├── test_arithmetic_cpp_int_20.cpp
│ │ │ ├── test_arithmetic_cpp_int_21.cpp
│ │ │ ├── test_arithmetic_cpp_int_22.cpp
│ │ │ ├── test_arithmetic_cpp_int_23.cpp
│ │ │ ├── test_arithmetic_cpp_int_3.cpp
│ │ │ ├── test_arithmetic_cpp_int_4.cpp
│ │ │ ├── test_arithmetic_cpp_int_5.cpp
│ │ │ ├── test_arithmetic_cpp_int_6.cpp
│ │ │ ├── test_arithmetic_cpp_int_7.cpp
│ │ │ ├── test_arithmetic_cpp_int_8.cpp
│ │ │ ├── test_arithmetic_cpp_int_9.cpp
│ │ │ ├── test_arithmetic_cpp_int_br.cpp
│ │ │ ├── test_arithmetic_cpp_int_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_cpp_int_logged_adptr.cpp
│ │ │ ├── test_arithmetic_cpp_rat_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_cpp_rat_logged_adptr.cpp
│ │ │ ├── test_arithmetic_dbg_adptr1.cpp
│ │ │ ├── test_arithmetic_dbg_adptr1m.cpp
│ │ │ ├── test_arithmetic_dbg_adptr2.cpp
│ │ │ ├── test_arithmetic_float_128.cpp
│ │ │ ├── test_arithmetic_logged_1.cpp
│ │ │ ├── test_arithmetic_logged_2.cpp
│ │ │ ├── test_arithmetic_mpc.cpp
│ │ │ ├── test_arithmetic_mpc_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_mpc_logged_adptr.cpp
│ │ │ ├── test_arithmetic_mpf.cpp
│ │ │ ├── test_arithmetic_mpf_50.cpp
│ │ │ ├── test_arithmetic_mpf_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_mpf_logged_adptr.cpp
│ │ │ ├── test_arithmetic_mpfi_50.cpp
│ │ │ ├── test_arithmetic_mpfi_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_mpfi_logged_adptr.cpp
│ │ │ ├── test_arithmetic_mpfr.cpp
│ │ │ ├── test_arithmetic_mpfr_50.cpp
│ │ │ ├── test_arithmetic_mpfr_50_mixed.cpp
│ │ │ ├── test_arithmetic_mpfr_50_static.cpp
│ │ │ ├── test_arithmetic_mpfr_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_mpfr_logged_adptr.cpp
│ │ │ ├── test_arithmetic_mpq.cpp
│ │ │ ├── test_arithmetic_mpq_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_mpq_logged_adptr.cpp
│ │ │ ├── test_arithmetic_mpz.cpp
│ │ │ ├── test_arithmetic_mpz_br.cpp
│ │ │ ├── test_arithmetic_mpz_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_mpz_logged_adptr.cpp
│ │ │ ├── test_arithmetic_mpz_rat.cpp
│ │ │ ├── test_arithmetic_skeleton.cpp
│ │ │ ├── test_arithmetic_tommath.cpp
│ │ │ ├── test_arithmetic_tommath_br.cpp
│ │ │ ├── test_arithmetic_tommath_rat.cpp
│ │ │ ├── test_asin.cpp
│ │ │ ├── test_assume_uniform_precision.cpp
│ │ │ ├── test_atan.cpp
│ │ │ ├── test_checked_cpp_int.cpp
│ │ │ ├── test_checked_mixed_cpp_int.cpp
│ │ │ ├── test_complex.cpp
│ │ │ ├── test_complex_signed_zero.cpp
│ │ │ ├── test_constants.cpp
│ │ │ ├── test_constexpr.cpp
│ │ │ ├── test_convert_cpp_int_2_float.cpp
│ │ │ ├── test_convert_from_cpp_bin_float.cpp
│ │ │ ├── test_convert_from_cpp_dec_float.cpp
│ │ │ ├── test_convert_from_cpp_int.cpp
│ │ │ ├── test_convert_from_cpp_rational.cpp
│ │ │ ├── test_convert_from_float128.cpp
│ │ │ ├── test_convert_from_gmp_rational.cpp
│ │ │ ├── test_convert_from_mpf_float.cpp
│ │ │ ├── test_convert_from_mpfi_float.cpp
│ │ │ ├── test_convert_from_mpfr_float.cpp
│ │ │ ├── test_convert_from_mpz_int.cpp
│ │ │ ├── test_convert_from_tom_int.cpp
│ │ │ ├── test_convert_from_tom_rational.cpp
│ │ │ ├── test_cos.cpp
│ │ │ ├── test_cos_near_half_pi.cpp
│ │ │ ├── test_cosh.cpp
│ │ │ ├── test_cpp_bin_float.cpp
│ │ │ ├── test_cpp_bin_float_conv.cpp
│ │ │ ├── test_cpp_bin_float_io.cpp
│ │ │ ├── test_cpp_bin_float_round.cpp
│ │ │ ├── test_cpp_bin_float_serial.cpp
│ │ │ ├── test_cpp_bin_float_tgamma.cpp
│ │ │ ├── test_cpp_dec_float_conv.cpp
│ │ │ ├── test_cpp_dec_float_round.cpp
│ │ │ ├── test_cpp_dec_float_serial.cpp
│ │ │ ├── test_cpp_dec_float_tgamma.cpp
│ │ │ ├── test_cpp_int.cpp
│ │ │ ├── test_cpp_int_conv.cpp
│ │ │ ├── test_cpp_int_deserial.cpp
│ │ │ ├── test_cpp_int_import_export.cpp
│ │ │ ├── test_cpp_int_karatsuba.cpp
│ │ │ ├── test_cpp_int_left_shift.cpp
│ │ │ ├── test_cpp_int_lit.cpp
│ │ │ ├── test_cpp_int_serial.cpp
│ │ │ ├── test_cpp_rat_serial.cpp
│ │ │ ├── test_cpp_rational.cpp
│ │ │ ├── test_eigen_interop.cpp
│ │ │ ├── test_eigen_interop_cpp_bin_float_1.cpp
│ │ │ ├── test_eigen_interop_cpp_bin_float_2.cpp
│ │ │ ├── test_eigen_interop_cpp_bin_float_3.cpp
│ │ │ ├── test_eigen_interop_cpp_dec_float.cpp
│ │ │ ├── test_eigen_interop_cpp_dec_float_2.cpp
│ │ │ ├── test_eigen_interop_cpp_dec_float_3.cpp
│ │ │ ├── test_eigen_interop_cpp_int.cpp
│ │ │ ├── test_eigen_interop_gmp.cpp
│ │ │ ├── test_eigen_interop_gmp_2.cpp
│ │ │ ├── test_eigen_interop_mpc.cpp
│ │ │ ├── test_eigen_interop_mpfr_1.cpp
│ │ │ ├── test_eigen_interop_mpfr_2.cpp
│ │ │ ├── test_eigen_interop_mpfr_3.cpp
│ │ │ ├── test_eigen_interop_mpfr_4.cpp
│ │ │ ├── test_eigen_interop_mpfr_5.cpp
│ │ │ ├── test_eigen_interop_mpfr_6.cpp
│ │ │ ├── test_exp.cpp
│ │ │ ├── test_fixed_int.cpp
│ │ │ ├── test_fixed_zero_precision_io.cpp
│ │ │ ├── test_float128_serial.cpp
│ │ │ ├── test_float_conversions.cpp
│ │ │ ├── test_float_io.cpp
│ │ │ ├── test_float_serial.hpp
│ │ │ ├── test_fpclassify.cpp
│ │ │ ├── test_gcd.cpp
│ │ │ ├── test_generic_conv.cpp
│ │ │ ├── test_gmp_conversions.cpp
│ │ │ ├── test_hash.cpp
│ │ │ ├── test_int_io.cpp
│ │ │ ├── test_int_sqrt.cpp
│ │ │ ├── test_log.cpp
│ │ │ ├── test_miller_rabin.cpp
│ │ │ ├── test_mixed.hpp
│ │ │ ├── test_mixed_cpp_bin_float.cpp
│ │ │ ├── test_mixed_cpp_dec_float.cpp
│ │ │ ├── test_mixed_cpp_int.cpp
│ │ │ ├── test_mixed_float.cpp
│ │ │ ├── test_mixed_move_cpp_int.cpp
│ │ │ ├── test_mixed_mpf_float.cpp
│ │ │ ├── test_mixed_mpfr_float.cpp
│ │ │ ├── test_move.cpp
│ │ │ ├── test_mpc_conversions.cpp
│ │ │ ├── test_mpc_overloads.cpp
│ │ │ ├── test_mpf_precisions.cpp
│ │ │ ├── test_mpfi.cpp
│ │ │ ├── test_mpfi_precisions.cpp
│ │ │ ├── test_mpfr_conversions.cpp
│ │ │ ├── test_mpfr_mpc_precisions.cpp
│ │ │ ├── test_native_integer.cpp
│ │ │ ├── test_nothrow_cpp_bin_float.cpp
│ │ │ ├── test_nothrow_cpp_dec_float.cpp
│ │ │ ├── test_nothrow_cpp_int.cpp
│ │ │ ├── test_nothrow_cpp_rational.cpp
│ │ │ ├── test_nothrow_float128.cpp
│ │ │ ├── test_nothrow_gmp.cpp
│ │ │ ├── test_nothrow_mpfr.cpp
│ │ │ ├── test_numeric_limits.cpp
│ │ │ ├── test_optional_compat.cpp
│ │ │ ├── test_pow.cpp
│ │ │ ├── test_preserve_all_precision.cpp
│ │ │ ├── test_preserve_component_precision.cpp
│ │ │ ├── test_preserve_related_precision.cpp
│ │ │ ├── test_preserve_source_precision.cpp
│ │ │ ├── test_preserve_target_precision.cpp
│ │ │ ├── test_rat_float_interconv.cpp
│ │ │ ├── test_rational_io.cpp
│ │ │ ├── test_roots_10k_digits.cpp
│ │ │ ├── test_round.cpp
│ │ │ ├── test_sf_import_c99.cpp
│ │ │ ├── test_signed_zero.cpp
│ │ │ ├── test_sin.cpp
│ │ │ ├── test_sin_near_half_pi.cpp
│ │ │ ├── test_sinh.cpp
│ │ │ ├── test_sqrt.cpp
│ │ │ ├── test_tan.cpp
│ │ │ ├── test_tanh.cpp
│ │ │ ├── test_test.cpp
│ │ │ ├── test_threaded_precision.cpp
│ │ │ ├── test_trailing_io_delim.cpp
│ │ │ ├── test_unchecked_cpp_int.cpp
│ │ │ ├── timer.hpp
│ │ │ └── ublas_interop/
│ │ │ ├── common/
│ │ │ │ ├── init.hpp
│ │ │ │ └── testhelper.hpp
│ │ │ ├── test1.cpp
│ │ │ ├── test1.hpp
│ │ │ ├── test11.cpp
│ │ │ ├── test12.cpp
│ │ │ ├── test13.cpp
│ │ │ ├── test2.cpp
│ │ │ ├── test2.hpp
│ │ │ ├── test21.cpp
│ │ │ ├── test22.cpp
│ │ │ ├── test23.cpp
│ │ │ ├── test3.cpp
│ │ │ ├── test3.hpp
│ │ │ ├── test31.cpp
│ │ │ ├── test32.cpp
│ │ │ ├── test33.cpp
│ │ │ ├── test4.cpp
│ │ │ ├── test4.hpp
│ │ │ ├── test42.cpp
│ │ │ ├── test43.cpp
│ │ │ ├── test5.cpp
│ │ │ ├── test5.hpp
│ │ │ ├── test52.cpp
│ │ │ ├── test53.cpp
│ │ │ ├── test6.cpp
│ │ │ ├── test6.hpp
│ │ │ ├── test62.cpp
│ │ │ ├── test63.cpp
│ │ │ ├── test7.cpp
│ │ │ ├── test7.hpp
│ │ │ ├── test71.cpp
│ │ │ ├── test72.cpp
│ │ │ └── test73.cpp
│ │ └── tools/
│ │ └── sincos.cpp
│ └── rapidcsv/
│ ├── .travis.yml
│ ├── CMakeLists.txt
│ ├── LICENSE
│ ├── README.md
│ ├── appveyor.yml
│ ├── doc/
│ │ ├── README.md
│ │ ├── rapidcsv_Converter.md
│ │ ├── rapidcsv_ConverterParams.md
│ │ ├── rapidcsv_Document.md
│ │ ├── rapidcsv_LabelParams.md
│ │ ├── rapidcsv_SeparatorParams.md
│ │ └── rapidcsv_no_converter.md
│ ├── examples/
│ │ ├── colhdr.csv
│ │ ├── colrowhdr.csv
│ │ ├── ex001.cpp
│ │ ├── ex002.cpp
│ │ ├── ex003.cpp
│ │ ├── ex004.cpp
│ │ ├── ex005.cpp
│ │ ├── ex006.cpp
│ │ ├── ex007.cpp
│ │ ├── ex008.cpp
│ │ ├── ex009.cpp
│ │ ├── nohdr.csv
│ │ ├── rowhdr.csv
│ │ └── semi.csv
│ ├── run.sh
│ ├── src/
│ │ └── rapidcsv.h
│ ├── tests/
│ │ ├── msft.csv
│ │ ├── perftest.h
│ │ ├── ptest001.cpp
│ │ ├── ptest002.cpp
│ │ ├── test001.cpp
│ │ ├── test002.cpp
│ │ ├── test003.cpp
│ │ ├── test004.cpp
│ │ ├── test005.cpp
│ │ ├── test006.cpp
│ │ ├── test007.cpp
│ │ ├── test008.cpp
│ │ ├── test009.cpp
│ │ ├── test010.cpp
│ │ ├── test011.cpp
│ │ ├── test012.cpp
│ │ ├── test013.cpp
│ │ ├── test014.cpp
│ │ ├── test015.cpp
│ │ ├── test016.cpp
│ │ ├── test017.cpp
│ │ ├── test018.cpp
│ │ ├── test019.cpp
│ │ ├── test020.cpp
│ │ ├── test021.cpp
│ │ ├── test022.cpp
│ │ ├── test023.cpp
│ │ ├── test024.cpp
│ │ ├── test025.cpp
│ │ ├── test026.cpp
│ │ ├── test027.cpp
│ │ ├── test028.cpp
│ │ ├── test029.cpp
│ │ ├── test030.cpp
│ │ ├── test031.cpp
│ │ ├── test032.cpp
│ │ ├── test033.cpp
│ │ ├── test034.cpp
│ │ ├── test035.cpp
│ │ ├── test036.cpp
│ │ ├── test037.cpp
│ │ ├── test038.cpp
│ │ ├── test039.cpp
│ │ ├── test040.cpp
│ │ ├── test040b.cpp
│ │ ├── test041.cpp
│ │ ├── test042.cpp
│ │ ├── test043.cpp
│ │ ├── test044.cpp
│ │ ├── test045.cpp
│ │ ├── test046.cpp
│ │ ├── test047.cpp
│ │ ├── test048.cpp
│ │ ├── test049.cpp
│ │ ├── test050.cpp
│ │ ├── test051.cpp
│ │ ├── test052.cpp
│ │ ├── test053.cpp
│ │ ├── test054.cpp
│ │ ├── test055.cpp
│ │ ├── test056.cpp
│ │ ├── test057.cpp
│ │ ├── test058.cpp
│ │ ├── test059.cpp
│ │ ├── test060.cpp
│ │ ├── test061.cpp
│ │ ├── test062.cpp
│ │ ├── test063.cpp
│ │ ├── test064.cpp
│ │ ├── test065.cpp
│ │ ├── test066.cpp
│ │ └── unittest.h
│ └── uncrustify.cfg
└── test.ipynb
================================================
FILE CONTENTS
================================================
================================================
FILE: README.md
================================================
# C++20 Fundamentals LiveLessons Code Examples
Source code examples for our **C++20 Fundamentals LiveLessons** Videos.
At 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
These source-code files are (C) Copyright 2021 by Deitel & Associates, Inc. and Pearson Education, Inc. All Rights Reserved.
You may use these files for your personal purposes, but please do not repost them without our express written consent.
If you have any questions, open an issue in the Issues tab or email us: deitel at deitel dot com.
The 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.
================================================
FILE: examples/docker/gcc13/dockerfile
================================================
FROM ubuntu:20.04
RUN apt-get update -y
RUN apt-get install -y build-essential wget
RUN wget --quiet --content-disposition http://kayari.org/gcc-latest/gcc-latest.deb
RUN dpkg -i gcc-latest*.deb
RUN /opt/gcc-latest/bin/g++ --version
================================================
FILE: examples/lesson01/GuessNumber.cpp
================================================
// Randomly generate numbers between 1 and 1000 for user to guess.
#include <iostream>
#include <random> // contains C++11 random number generation features
using namespace std;
bool isCorrect(int, int); // function prototype
int main() {
// use the default random-number generation engine to
// produce uniformly distributed pseudorandom int values from 1 to 1000
default_random_engine engine{random_device{}()};
uniform_int_distribution<int> randomInt{1, 1000};
char response = 'n'; // determines whether to continue playing
// loop until user types 'n' to quit game
do {
// generate random number between 1 and 1000
// 1 is shift, 1000 is scaling factor
const int answer{randomInt(engine)};
// prompt for guess
cout << "I have a number between 1 and 1000.\n"
<< "Can you guess my number?\n"
<< "Please type your first guess.\n? ";
int guess;
cin >> guess;
// loop until correct number
while (!isCorrect(guess, answer)) {
cin >> guess;
}
// prompt for another game
cout << "\nExcellent! You guessed the number!\n"
<< "Would you like to play again (y or n)? ";
cin >> response;
cout << endl;
} while (response == 'y');
return 0; // indicate successful termination
}
// isCorrect returns true if guess equals answer;
// otherwise it displays a hint and returns false
bool isCorrect(int guess, int answer) {
// guess is correct
if (guess == answer) {
return true;
}
// guess is incorrect; display hint
if (guess < answer) {
cout << "Too low. Try again.\n? ";
}
else {
cout << "Too high. Try again.\n? ";
}
return false;
} // end function isCorrect
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
**************************************************************************/
================================================
FILE: examples/lesson02/fig02_01.cpp
================================================
// fig02_01.cpp
// Text-printing program.
#include <iostream> // enables program to output data to the screen
// function main begins program execution
int main() {
std::cout << "Welcome to C++!\n"; // display message
return 0; // indicate that program ended successfully
} // end function main
/*************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
**************************************************************************/
================================================
FILE: examples/lesson02/fig02_02.cpp
================================================
// fig02_02.cpp
// Displaying a line of text with multiple statements.
#include <iostream> // enables program to output data to the screen
// function main begins program execution
int main() {
std::cout << "Welcome ";
std::cout << "to C++!\n";
} // end function main
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
**************************************************************************/
================================================
FILE: examples/lesson02/fig02_03.cpp
================================================
// fig02_03.cpp
// Displayings multiple lines of text with a single statement.
#include <iostream> // enables program to output data to the screen
// function main begins program execution
int main() {
std::cout << "Welcome\nto\n\nC++!\n";
} // end function main
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
**************************************************************************/
================================================
FILE: examples/lesson02/fig02_04.cpp
================================================
// fig02_04.cpp
// Addition program that displays the sum of two integers.
#include <iostream> // enables program to perform input and output
// function main begins program execution
int main() {
// declaring and initializing variables
int number1{0}; // first integer to add (initialized to 0)
int number2{0}; // second integer to add (initialized to 0)
int sum{0}; // sum of number1 and number2 (initialized to 0)
std::cout << "Enter first integer: "; // prompt user for data
std::cin >> number1; // read first integer from user into number1
std::cout << "Enter second integer: "; // prompt user for data
std::cin >> number2; // read second integer from user into number2
sum = number1 + number2; // add the numbers; store result in sum
std::cout << "Sum is " << sum << "\n"; // display sum
} // end function main
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
**************************************************************************/
================================================
FILE: examples/lesson02/fig02_05.cpp
================================================
// fig02_05.cpp
// Comparing integers using if statements, relational operators
// and equality operators.
#include <iostream> // enables program to perform input and output
using std::cout; // program uses cout
using std::cin; // program uses cin
// function main begins program execution
int main() {
int number1{0}; // first integer to compare (initialized to 0)
int number2{0}; // second integer to compare (initialized to 0)
cout << "Enter two integers to compare: "; // prompt user for data
cin >> number1 >> number2; // read two integers from user
if (number1 == number2) {
cout << number1 << " == " << number2 << "\n";
}
if (number1 != number2) {
cout << number1 << " != " << number2 << "\n";
}
if (number1 < number2) {
cout << number1 << " < " << number2 << "\n";
}
if (number1 > number2) {
cout << number1 << " > " << number2 << "\n";
}
if (number1 <= number2) {
cout << number1 << " <= " << number2 << "\n";
}
if (number1 >= number2) {
cout << number1 << " >= " << number2 << "\n";
}
} // end function main
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
**************************************************************************/
================================================
FILE: examples/lesson02/fig02_06.cpp
================================================
// fig02_06.cpp
// Standard library string class test program.
#include <iostream>
#include <string>
using namespace std;
int main() {
string s1{"happy"};
string s2{" birthday"};
string s3; // creates an empty string
// display the strings and show their lengths (length is C++20)
cout << "s1: \"" << s1 << "\"; length: " << s1.length()
<< "\ns2: \"" << s2 << "\"; length: " << s2.length()
<< "\ns3: \"" << s3 << "\"; length: " << s3.length();
// compare strings with == and !=
cout << "\n\nThe results of comparing s2 and s1:" << boolalpha
<< "\ns2 == s1: " << (s2 == s1)
<< "\ns2 != s1: " << (s2 != s1);
// test string member function empty
cout << "\n\nTesting s3.empty():\n";
if (s3.empty()) {
cout << "s3 is empty; assigning to s3;\n";
s3 = s1 + s2; // assign s3 the result of concatenating s1 and s2
cout << "s3: \"" << s3 << "\"";
}
// testing new C++20 string member functions
cout << "\n\ns1 starts with \"ha\": " << s1.starts_with("ha") << "\n";
cout << "s2 starts with \"ha\": " << s2.starts_with("ha") << "\n";
cout << "s1 ends with \"ay\": " << s1.ends_with("ay") << "\n";
cout << "s2 ends with \"ay\": " << s2.ends_with("ay") << "\n";
}
/**************************************************************************
* (C) Copyright 1992-2022 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
**************************************************************************/
================================================
FILE: examples/lesson03/fig03_01.cpp
================================================
// fig03_01.cpp
// Solving the class-average problem using counter-controlled iteration.
#include <iostream>
using namespace std;
int main() {
// initialization phase
int total{0}; // initialize sum of grades entered by the user
int gradeCounter{1}; // initialize grade # to be entered next
// processing phase uses counter-controlled iteration
while (gradeCounter <= 10) { // loop 10 times
cout << "Enter grade: "; // prompt
int grade;
cin >> grade; // input next grade
total = total + grade; // add grade to total
gradeCounter = gradeCounter + 1; // increment counter by 1
}
// termination phase
int average{total / 10}; // int division yields int result
// display total and average of grades
cout << "\nTotal of all 10 grades is " << total;
cout << "\nClass average is " << average << "\n";
}
/**************************************************************************
* (C) Copyright 1992-2022 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson03/fig03_02.cpp
================================================
// fig03_02.cpp
// Solving the class-average problem using sentinel-controlled iteration.
#include <iostream>
#include <iomanip> // parameterized stream manipulators
using namespace std;
int main() {
// initialization phase
double total{0.0}; // initialize sum of grades
int gradeCounter{0}; // initialize # of grades entered so far
// processing phase
// prompt for input and read grade from user
cout << "Enter grade or -1 to quit: ";
int grade;
cin >> grade;
// loop until sentinel value is read from user
while (grade != -1) {
total = total + grade; // add grade to total
gradeCounter = gradeCounter + 1; // increment counter
// prompt for input and read next grade from user
cout << "Enter grade or -1 to quit: ";
cin >> grade;
}
// termination phase
// if user entered at least one grade
if (gradeCounter != 0) { // avoid division by zero
// calculate average of grades
double average{total / gradeCounter};
// display total and average (with two digits of precision)
cout << "\nTotal of the " << gradeCounter
<< " grades entered is " << total;
cout << setprecision(2) << fixed;
cout << "\nClass average is " << average << "\n";
}
else { // no grades were entered, so output appropriate message
cout << "No grades were entered\n";
}
}
/**************************************************************************
* (C) Copyright 1992-2022 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson03/fig03_03.cpp
================================================
// fig03_03.cpp
// Analysis of examination results using nested control statements.
#include <iostream>
using namespace std;
int main() {
// initializing variables in declarations
int passes{0};
int failures{0};
int studentCounter{1};
// process 10 students using counter-controlled loop
while (studentCounter <= 10) {
// prompt user for input and obtain value from user
cout << "Enter result (1 = pass, 2 = fail): ";
int result;
cin >> result;
// if...else is nested in the while statement
if (result == 1) {
passes = passes + 1;
}
else {
failures = failures + 1;
}
// increment studentCounter so loop eventually terminates
studentCounter = studentCounter + 1;
}
// termination phase; prepare and display results
cout << "Passed: " << passes << "\nFailed: " << failures << "\n";
// determine whether more than 8 students passed
if (passes > 8) {
cout << "Bonus to instructor!\n";
}
}
/**************************************************************************
* (C) Copyright 1992-2022 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson03/fig03_04.cpp
================================================
// fig03_04.cpp
// Prefix increment and postfix increment operators.
#include <iostream>
using namespace std;
int main() {
// demonstrate postfix increment operator
int c{5};
cout << "c before postincrement: " << c << "\n"; // prints 5
cout << " postincrementing c: " << c++ << "\n"; // prints 5
cout << " c after postincrement: " << c << "\n"; // prints 6
cout << "\n"; // skip a line
// demonstrate prefix increment operator
c = 5;
cout << " c before preincrement: " << c << "\n"; // prints 5
cout << " preincrementing c: " << ++c << "\n"; // prints 6
cout << " c after preincrement: " << c << "\n"; // prints 6
}
/**************************************************************************
* (C) Copyright 1992-2022 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson03/fig03_05.cpp
================================================
// fig03_05.cpp
// Conveniently creating and manipulating super-sized integers
// with objects of the Boost Multiprecision library's cpp_int class.
#include <boost/multiprecision/cpp_int.hpp>
#include <iostream>
using namespace std;
using boost::multiprecision::cpp_int;
int main() {
// initializing cpp_ints
const cpp_int value1{"100000000000000000000000000000"}; // 30 digits
const cpp_int value2{9223372036854775807LL}; // long long max
const int value3{3};
cout << "INITIAL VALUES"
<< "\ncpp_int value1: " << value1
<< "\ncpp_int value2: " << value2
<< "\n int value3: " << value3;
// arithmetic with cpp_ints
cout << "\n\nADD, SUBTRACT AND MULTIPLY CPP_INT OBJECTS"
<< "\nvalue1 + value2: " << value1 + value2
<< "\nvalue1 - value2: " << value1 - value2
<< "\nvalue1 * value2: " << value1 * value2;
// arithmetic mixing cpp_ints and integers
cout << "\n\nMULTIPLY A CPP_INT OBJECT BY INT VALUES"
<< "\nvalue1 * value3: " << value1 * value3
<< "\n value1 * 17: " << value1 * 17 << "\n";
}
/**************************************************************************
* (C) Copyright 1992-2022 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
**************************************************************************/
================================================
FILE: examples/lesson04/decimalformatter.h
================================================
// decimalformatter.h
// Custom std::formatter that formats a
// boost::multiprecision::cpp_dec_float_50 as a std::string
// with two digits to the right of the decimal point.
#pragma once
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <format>
#include <iomanip>
#include <sstream>
#include <string>
// short name for boost::multiprecision::cpp_dec_float_50
using decimal = boost::multiprecision::cpp_dec_float_50;
// Custom formatter for boost::multiprecision::cpp_dec_float_50.
// Formats as a string with two digits to the right of the decimal point.
// More info at: https://fmt.dev/latest/api.html#format-api
template<> struct std::formatter<decimal> : std::formatter<string_view> {
template <typename FormatContext>
auto format(decimal d, FormatContext& ctx) const {
std::ostringstream out{};
out << std::fixed << std::setprecision(2) << d;
return formatter<string_view>::format(out.str(), ctx);
}
};
================================================
FILE: examples/lesson04/decimalformatter_fmt.h
================================================
// decimalformatter.h
// Custom fmt::formatter that formats a
// boost::multiprecision::cpp_dec_float_50 as a std::string
// with two digits to the right of the decimal point.
#pragma once
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <fmt/format.h> // in C++20, this will be #include <format>
#include <iomanip>
#include <sstream>
#include <string>
// short name for boost::multiprecision::cpp_dec_float_50
using decimal = boost::multiprecision::cpp_dec_float_50;
// Custom formatter for boost::multiprecision::cpp_dec_float_50.
// Formats as a string with two digits to the right of the decimal point.
// More info at: https://fmt.dev/latest/api.html#format-api
template<> struct fmt::formatter<decimal> : fmt::formatter<string_view> {
template <typename FormatContext>
auto format(decimal d, FormatContext& ctx) const {
std::ostringstream out{};
out << std::fixed << std::setprecision(2) << d;
return formatter<string_view>::format(out.str(), ctx);
}
};
================================================
FILE: examples/lesson04/ex04_06.cpp
================================================
// ex04_06.cpp
#include <iostream>
using namespace std;
int main() {
for (int i{1}; i <= 10; i++) {
for (int j{1}; j <= 5; j++) {
cout << '@';
}
cout << '\n';
}
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_01.cpp
================================================
// fig04_01.cpp
// Counter-controlled iteration with the while iteration statement.
#include <iostream>
using namespace std;
int main() {
int counter{1}; // declare and initialize control variable
while (counter <= 10) { // loop-continuation condition
cout << counter << " ";
++counter; // increment control variable
}
cout << "\n";
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_02.cpp
================================================
// fig04_02.cpp
// Counter-controlled iteration with the for iteration statement.
#include <iostream>
using namespace std;
int main() {
// for statement header includes initialization,
// loop-continuation condition and increment
for (int counter{1}; counter <= 10; ++counter) {
cout << counter << " ";
}
cout << "\n";
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_03.cpp
================================================
// fig04_03.cpp
// Summing integers with the for statement; introducing text formatting.
#include <format>
#include <iostream>
using namespace std;
int main() {
int total{0};
// total even integers from 2 through 20
for (int number{2}; number <= 20; number += 2) {
total += number;
}
cout << format("Sum is {}\n", total);
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_03fmt.cpp
================================================
// fig04_03.cpp
// Summing integers with the for statement; introducing text formatting.
#include <fmt/format.h> // C++20: This will be #include <format>
#include <iostream>
using namespace std;
int main() {
int total{0};
// total even integers from 2 through 20
for (int number{2}; number <= 20; number += 2) {
total += number;
}
cout << fmt::format("Sum is {}\n", total);
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_04.cpp
================================================
// fig04_04.cpp
// Compound-interest calculations with for.
#include <format>
#include <iostream>
#include <cmath> // for pow function
using namespace std;
int main() {
double principal{1000.00}; // initial amount before interest
double rate{0.05}; // interest rate
cout << format("Initial principal: {:>7.2f}\n", principal)
<< format(" Interest rate: {:>7.2f}\n", rate);
// display headers
cout << format("\n{}{:>20}\n", "Year", "Amount on deposit");
// calculate amount on deposit for each of ten years
for (int year{1}; year <= 10; ++year) {
// calculate amount on deposit at the end of the specified year
double amount{principal * pow(1.0 + rate, year)} ;
// display the year and the amount
cout << format("{:>4d}{:>20.2f}\n", year, amount);
}
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_04fmt.cpp
================================================
// fig04_04.cpp
// Compound-interest calculations with for.
#include <fmt/format.h> // C++20: This will be #include <format>
#include <iostream>
#include <cmath> // for pow function
using namespace std;
int main() {
double principal{1000.00}; // initial amount before interest
double rate{0.05}; // interest rate
cout << fmt::format("Initial principal: {:>7.2f}\n", principal)
<< fmt::format(" Interest rate: {:>7.2f}\n", rate);
// display headers
cout << fmt::format("\n{}{:>20}\n", "Year", "Amount on deposit");
// calculate amount on deposit for each of ten years
for (int year{1}; year <= 10; ++year) {
// calculate amount on deposit at the end of the specified year
double amount{principal * pow(1.0 + rate, year)} ;
// display the year and the amount
cout << fmt::format("{:>4d}{:>20.2f}\n", year, amount);
}
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_05.cpp
================================================
// fig04_05.cpp
// do...while iteration statement.
#include <iostream>
using namespace std;
int main() {
int counter{1};
do {
cout << counter << " ";
++counter;
} while (counter <= 10); // end do...while
cout << "\n";
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_06.cpp
================================================
// fig04_06.cpp
// Using a switch statement to count letter grades.
#include <format>
#include <iostream>
using namespace std;
int main() {
double total{0.0}; // sum of grades
int gradeCounter{0}; // number of grades entered
int aCount{0}; // count of A grades
int bCount{0}; // count of B grades
int cCount{0}; // count of C grades
int dCount{0}; // count of D grades
int fCount{0}; // count of F grades
cout << "Enter the integer grades in the range 0-100.\n"
<< "Type the end-of-file indicator to terminate input:\n"
<< " On UNIX/Linux/macOS type <Ctrl> d then press Enter\n"
<< " On Windows type <Ctrl> z then press Enter\n";
int grade;
// loop until user enters the end-of-file indicator
while (cin >> grade) {
total += grade; // add grade to total
++gradeCounter; // increment number of grades
// increment appropriate letter-grade counter
switch (grade / 10) {
case 9: // grade was between 90
case 10: // and 100, inclusive
++aCount;
break; // exits switch
case 8: // grade was between 80 and 89
++bCount;
break; // exits switch
case 7: // grade was between 70 and 79
++cCount;
break; // exits switch
case 6: // grade was between 60 and 69
++dCount;
break; // exits switch
default: // grade was less than 60
++fCount;
break; // optional; exits switch anyway
} // end switch
} // end while
// display grade report
cout << "\nGrade Report:\n";
// if user entered at least one grade...
if (gradeCounter != 0) {
// calculate average of all grades entered
double average{total / gradeCounter};
// output summary of results
cout << format("Total of the {} grades entered is {}\n",
gradeCounter, total)
<< format("Class average is {:.2f}\n\n", average)
<< "Summary of student's grades:\n"
<< format("A: {}\nB: {}\nC: {}\nD: {}\nF: {}\n",
aCount, bCount, cCount, dCount, fCount);
}
else { // no grades were entered, so output appropriate message
cout << "No grades were entered\n";
}
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_06fmt.cpp
================================================
// fig04_06.cpp
// Using a switch statement to count letter grades.
#include <fmt/format.h> // C++20: This will be #include <format>
#include <iostream>
using namespace std;
int main() {
double total{0.0}; // sum of grades
int gradeCounter{0}; // number of grades entered
int aCount{0}; // count of A grades
int bCount{0}; // count of B grades
int cCount{0}; // count of C grades
int dCount{0}; // count of D grades
int fCount{0}; // count of F grades
cout << "Enter the integer grades in the range 0-100.\n"
<< "Type the end-of-file indicator to terminate input:\n"
<< " On UNIX/Linux/macOS type <Ctrl> d then press Enter\n"
<< " On Windows type <Ctrl> z then press Enter\n";
int grade;
// loop until user enters the end-of-file indicator
while (cin >> grade) {
total += grade; // add grade to total
++gradeCounter; // increment number of grades
// increment appropriate letter-grade counter
switch (grade / 10) {
case 9: // grade was between 90
case 10: // and 100, inclusive
++aCount;
break; // exits switch
case 8: // grade was between 80 and 89
++bCount;
break; // exits switch
case 7: // grade was between 70 and 79
++cCount;
break; // exits switch
case 6: // grade was between 60 and 69
++dCount;
break; // exits switch
default: // grade was less than 60
++fCount;
break; // optional; exits switch anyway
} // end switch
} // end while
// display grade report
cout << "\nGrade Report:\n";
// if user entered at least one grade...
if (gradeCounter != 0) {
// calculate average of all grades entered
double average{total / gradeCounter};
// output summary of results
cout << fmt::format("Total of the {} grades entered is {}\n",
gradeCounter, total)
<< fmt::format("Class average is {:.2f}\n\n", average)
<< "Summary of student's grades:\n"
<< fmt::format("A: {}\nB: {}\nC: {}\nD: {}\nF: {}\n",
aCount, bCount, cCount, dCount, fCount);
}
else { // no grades were entered, so output appropriate message
cout << "No grades were entered\n";
}
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_07.cpp
================================================
// fig04_07.cpp
// if statements with initializers.
#include <format>
#include <iostream>
using namespace std;
int main() {
if (int value{7}; value == 7) {
cout << format("value is {}\n", value);
}
else {
cout << format("value is not 7; it is {}\n", value);
}
if (int value{13}; value == 9) {
cout << format("value is {}\n", value);
}
else {
cout << format("value is not 9; it is {}\n", value);
}
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
**************************************************************************/
================================================
FILE: examples/lesson04/fig04_07_with_error.cpp
================================================
// fig04_07_with_error.cpp
// C++17 if statements with initializers.
#include <iostream>
using namespace std;
int main() {
if (int value{7}; value == 7) {
cout << "value is " << value << endl;
}
else {
cout << "value is not 7; it is " << value << endl;
}
if (int value{13}; value == 9) {
cout << "value is " << value << endl;
}
else {
cout << "value is not 9; it is " << value << endl;
}
cout << value;
}
/**************************************************************************
* (C) Copyright 1992-2020 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
**************************************************************************/
================================================
FILE: examples/lesson04/fig04_07fmt.cpp
================================================
// fig04_07.cpp
// if statements with initializers.
#include <fmt/format.h> // C++20: This will be #include <format>
#include <iostream>
using namespace std;
int main() {
if (int value{7}; value == 7) {
cout << fmt::format("value is {}\n", value);
}
else {
cout << fmt::format("value is not 7; it is {}\n", value);
}
if (int value{13}; value == 9) {
cout << fmt::format("value is {}\n", value);
}
else {
cout << fmt::format("value is not 9; it is {}\n", value);
}
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
**************************************************************************/
================================================
FILE: examples/lesson04/fig04_08.cpp
================================================
// fig04_08.cpp
// break statement exiting a for statement.
#include <iostream>
using namespace std;
int main() {
int count; // control variable also used after loop
for (count = 1; count <= 10; ++count) { // loop 10 times
if (count == 5) {
break; // terminates for loop if count is 5
}
cout << count << " ";
}
cout << "\nBroke out of loop at count = " << count << "\n";
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_09.cpp
================================================
// fig04_09.cpp
// continue statement terminating an iteration of a for statement.
#include <iostream>
using namespace std;
int main() {
for (int count{1}; count <= 10; ++count) { // loop 10 times
if (count == 5) {
continue; // skip remaining code in loop body if count is 5
}
cout << count << " ";
}
cout << "\nUsed continue to skip printing 5\n";
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_10.cpp
================================================
// fig04_10.cpp
// Logical operators.
#include <format>
#include <iostream>
using namespace std;
int main() {
// create truth table for && (logical AND) operator
cout << "Logical AND (&&)\n"
<< format("false && false: {}\n", false && false)
<< format("false && true: {}\n", false && true)
<< format("true && false: {}\n", true && false)
<< format("true && true: {}\n\n", true && true);
// create truth table for || (logical OR) operator
cout << "Logical OR (||)\n"
<< format("false || false: {}\n", false || false)
<< format("false || true: {}\n", false || true)
<< format("true || false: {}\n", true || false)
<< format("true || true: {}\n\n", true || true);
// create truth table for ! (logical negation) operator
cout << "Logical negation (!)\n"
<< format("!false: {}\n", !false)
<< format("!true: {}\n", !true);
}
/**************************************************************************
* (C) Copyright 1992-2023 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_11.cpp
================================================
// fig04_11.cpp
// Using the miniz-cpp header-only library to write and read a ZIP file.
#include <iostream>
#include <string>
#include "zip_file.hpp"
using namespace std;
int main() {
cout << "Enter a ZIP file name: ";
string zipFileName;
getline(cin, zipFileName); // inputs a line of text
// strings literals separated only by whitespace are combined
// into a single string by the compiler
string content{
"This chapter introduces all but one of the remaining control "
"statements--the for, do...while, switch, break and continue "
"statements. We explore the essentials of counter-controlled "
"iteration. We use compound-interest calculations to begin "
"investigating the issues of processing monetary amounts. First, "
"we discuss the representational errors associated with "
"floating-point types. We use a switch statement to count the "
"number of A, B, C, D and F grade equivalents in a set of "
"numeric grades. We show C++17's enhancements that allow you to "
"initialize one or more variables of the same type in the "
"headers of if and switch statements."};
cout << "\ncontent.length(): " << content.length();
miniz_cpp::zip_file output; // create zip_file object
// write content into a text file in outputZipFile
output.writestr("intro.txt", content); // create file in ZIP
output.save(zipFileName); // save outputZipFile to zipFileName
miniz_cpp::zip_file input{zipFileName}; // load zipFileName
// display input's file name and directory listing
cout << "\n\nZIP file's name: " << input.get_filename()
<< "\n\nZIP file's directory listing:\n";
input.printdir();
// display info about the compressed intro.txt file
miniz_cpp::zip_info info{input.getinfo("intro.txt")};
cout << "\nFile name: " << info.filename
<< "\nOriginal size: " << info.file_size
<< "\nCompressed size: " << info.compress_size;
// original file contents
string extractedContent{input.read(info)};
cout << "\n\nOriginal contents of intro.txt:\n" <<
extractedContent << endl;
}
/**************************************************************************
* (C) Copyright 1992-2020 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
*************************************************************************/
================================================
FILE: examples/lesson04/fig04_12/fig04_12.cpp
================================================
// fig04_12.cpp
// Compound-interest example with C++20 text formatting.
#include <iostream>
#include <cmath> // for pow function
#include "fmt/format.h" // in C++20, this will be #include <format>
using namespace std;
using namespace fmt; // not needed in C++20
int main() {
double principal{1000.00}; // initial amount before interest
double rate{0.05}; // interest rate
cout << format("Initial principal: {:>7.2f}\n", principal)
<< format(" Interest rate: {:>7.2f}\n", rate);
// display headers
cout << format("\n{}{:>20}\n", "Year", "Amount on deposit");
// calculate amount on deposit for each of ten years
for (int year{1}; year <= 10; ++year) {
// calculate amount on deposit at the end of the specified year
double amount = principal * pow(1.0 + rate, year);
// display the year and the amount
cout << format("{:>4d}{:>20.2f}\n", year, amount);
}
}
/**************************************************************************
* (C) Copyright 1992-2020 by Deitel & Associates, Inc. and *
* Pearson Education, Inc. All Rights Reserved. *
* *
* DISCLAIMER: The authors and publisher of this book have used their *
* best efforts in preparing the book. 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 books. 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. *
**************************************************************************/
================================================
FILE: examples/lesson04/fig04_12/fmt/core.h
================================================
// Formatting library for C++ - the core API
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
#ifndef FMT_CORE_H_
#define FMT_CORE_H_
#include <cstdio> // std::FILE
#include <cstring>
#include <functional>
#include <iterator>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
// The fmt library version in the form major * 10000 + minor * 100 + patch.
#define FMT_VERSION 60200
#ifdef __has_feature
# define FMT_HAS_FEATURE(x) __has_feature(x)
#else
# define FMT_HAS_FEATURE(x) 0
#endif
#if defined(__has_include) && !defined(__INTELLISENSE__) && \
!(defined(__INTEL_COMPILER) && __INTEL_COMPILER < 1600)
# define FMT_HAS_INCLUDE(x) __has_include(x)
#else
# define FMT_HAS_INCLUDE(x) 0
#endif
#ifdef __has_cpp_attribute
# define FMT_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
#else
# define FMT_HAS_CPP_ATTRIBUTE(x) 0
#endif
#define FMT_HAS_CPP14_ATTRIBUTE(attribute) \
(__cplusplus >= 201402L && FMT_HAS_CPP_ATTRIBUTE(attribute))
#define FMT_HAS_CPP17_ATTRIBUTE(attribute) \
(__cplusplus >= 201703L && FMT_HAS_CPP_ATTRIBUTE(attribute))
#ifdef __clang__
# define FMT_CLANG_VERSION (__clang_major__ * 100 + __clang_minor__)
#else
# define FMT_CLANG_VERSION 0
#endif
#if defined(__GNUC__) && !defined(__clang__)
# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
#else
# define FMT_GCC_VERSION 0
#endif
#if __cplusplus >= 201103L || defined(__GXX_EXPERIMENTAL_CXX0X__)
# define FMT_HAS_GXX_CXX11 FMT_GCC_VERSION
#else
# define FMT_HAS_GXX_CXX11 0
#endif
#ifdef __NVCC__
# define FMT_NVCC __NVCC__
#else
# define FMT_NVCC 0
#endif
#ifdef _MSC_VER
# define FMT_MSC_VER _MSC_VER
#else
# define FMT_MSC_VER 0
#endif
// Check if relaxed C++14 constexpr is supported.
// GCC doesn't allow throw in constexpr until version 6 (bug 67371).
#ifndef FMT_USE_CONSTEXPR
# define FMT_USE_CONSTEXPR \
(FMT_HAS_FEATURE(cxx_relaxed_constexpr) || FMT_MSC_VER >= 1910 || \
(FMT_GCC_VERSION >= 600 && __cplusplus >= 201402L)) && \
!FMT_NVCC
#endif
#if FMT_USE_CONSTEXPR
# define FMT_CONSTEXPR constexpr
# define FMT_CONSTEXPR_DECL constexpr
#else
# define FMT_CONSTEXPR inline
# define FMT_CONSTEXPR_DECL
#endif
#ifndef FMT_OVERRIDE
# if FMT_HAS_FEATURE(cxx_override) || \
(FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
# define FMT_OVERRIDE override
# else
# define FMT_OVERRIDE
# endif
#endif
// Check if exceptions are disabled.
#ifndef FMT_EXCEPTIONS
# if (defined(__GNUC__) && !defined(__EXCEPTIONS)) || \
FMT_MSC_VER && !_HAS_EXCEPTIONS
# define FMT_EXCEPTIONS 0
# else
# define FMT_EXCEPTIONS 1
# endif
#endif
// Define FMT_USE_NOEXCEPT to make fmt use noexcept (C++11 feature).
#ifndef FMT_USE_NOEXCEPT
# define FMT_USE_NOEXCEPT 0
#endif
#if FMT_USE_NOEXCEPT || FMT_HAS_FEATURE(cxx_noexcept) || \
(FMT_GCC_VERSION >= 408 && FMT_HAS_GXX_CXX11) || FMT_MSC_VER >= 1900
# define FMT_DETECTED_NOEXCEPT noexcept
# define FMT_HAS_CXX11_NOEXCEPT 1
#else
# define FMT_DETECTED_NOEXCEPT throw()
# define FMT_HAS_CXX11_NOEXCEPT 0
#endif
#ifndef FMT_NOEXCEPT
# if FMT_EXCEPTIONS || FMT_HAS_CXX11_NOEXCEPT
# define FMT_NOEXCEPT FMT_DETECTED_NOEXCEPT
# else
# define FMT_NOEXCEPT
# endif
#endif
// [[noreturn]] is disabled on MSVC and NVCC because of bogus unreachable code
// warnings.
#if FMT_EXCEPTIONS && FMT_HAS_CPP_ATTRIBUTE(noreturn) && !FMT_MSC_VER && \
!FMT_NVCC
# define FMT_NORETURN [[noreturn]]
#else
# define FMT_NORETURN
#endif
#ifndef FMT_MAYBE_UNUSED
# if FMT_HAS_CPP17_ATTRIBUTE(maybe_unused)
# define FMT_MAYBE_UNUSED [[maybe_unused]]
# else
# define FMT_MAYBE_UNUSED
# endif
#endif
#ifndef FMT_DEPRECATED
# if FMT_HAS_CPP14_ATTRIBUTE(deprecated) || FMT_MSC_VER >= 1900
# define FMT_DEPRECATED [[deprecated]]
# else
# if defined(__GNUC__) || defined(__clang__)
# define FMT_DEPRECATED __attribute__((deprecated))
# elif FMT_MSC_VER
# define FMT_DEPRECATED __declspec(deprecated)
# else
# define FMT_DEPRECATED /* deprecated */
# endif
# endif
#endif
// Workaround broken [[deprecated]] in the Intel, PGI and NVCC compilers.
#if defined(__INTEL_COMPILER) || defined(__PGI) || FMT_NVCC
# define FMT_DEPRECATED_ALIAS
#else
# define FMT_DEPRECATED_ALIAS FMT_DEPRECATED
#endif
#ifndef FMT_BEGIN_NAMESPACE
# if FMT_HAS_FEATURE(cxx_inline_namespaces) || FMT_GCC_VERSION >= 404 || \
FMT_MSC_VER >= 1900
# define FMT_INLINE_NAMESPACE inline namespace
# define FMT_END_NAMESPACE \
} \
}
# else
# define FMT_INLINE_NAMESPACE namespace
# define FMT_END_NAMESPACE \
} \
using namespace v6; \
}
# endif
# define FMT_BEGIN_NAMESPACE \
namespace fmt { \
FMT_INLINE_NAMESPACE v6 {
#endif
#if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
# if FMT_MSC_VER
# define FMT_NO_W4275 __pragma(warning(suppress : 4275))
# else
# define FMT_NO_W4275
# endif
# define FMT_CLASS_API FMT_NO_W4275
# ifdef FMT_EXPORT
# define FMT_API __declspec(dllexport)
# elif defined(FMT_SHARED)
# define FMT_API __declspec(dllimport)
# define FMT_EXTERN_TEMPLATE_API FMT_API
# endif
#endif
#ifndef FMT_CLASS_API
# define FMT_CLASS_API
#endif
#ifndef FMT_API
# if FMT_GCC_VERSION || FMT_CLANG_VERSION
# define FMT_API __attribute__((visibility("default")))
# define FMT_EXTERN_TEMPLATE_API FMT_API
# define FMT_INSTANTIATION_DEF_API
# else
# define FMT_API
# endif
#endif
#ifndef FMT_EXTERN_TEMPLATE_API
# define FMT_EXTERN_TEMPLATE_API
#endif
#ifndef FMT_INSTANTIATION_DEF_API
# define FMT_INSTANTIATION_DEF_API FMT_API
#endif
#ifndef FMT_HEADER_ONLY
# define FMT_EXTERN extern
#else
# define FMT_EXTERN
#endif
// libc++ supports string_view in pre-c++17.
#if (FMT_HAS_INCLUDE(<string_view>) && \
(__cplusplus > 201402L || defined(_LIBCPP_VERSION))) || \
(defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
# include <string_view>
# define FMT_USE_STRING_VIEW
#elif FMT_HAS_INCLUDE("experimental/string_view") && __cplusplus >= 201402L
# include <experimental/string_view>
# define FMT_USE_EXPERIMENTAL_STRING_VIEW
#endif
#ifndef FMT_UNICODE
# define FMT_UNICODE !FMT_MSC_VER
#endif
#if FMT_UNICODE && FMT_MSC_VER
# pragma execution_character_set("utf-8")
#endif
FMT_BEGIN_NAMESPACE
// Implementations of enable_if_t and other metafunctions for older systems.
template <bool B, class T = void>
using enable_if_t = typename std::enable_if<B, T>::type;
template <bool B, class T, class F>
using conditional_t = typename std::conditional<B, T, F>::type;
template <bool B> using bool_constant = std::integral_constant<bool, B>;
template <typename T>
using remove_reference_t = typename std::remove_reference<T>::type;
template <typename T>
using remove_const_t = typename std::remove_const<T>::type;
template <typename T>
using remove_cvref_t = typename std::remove_cv<remove_reference_t<T>>::type;
template <typename T> struct type_identity { using type = T; };
template <typename T> using type_identity_t = typename type_identity<T>::type;
struct monostate {};
// An enable_if helper to be used in template parameters which results in much
// shorter symbols: https://godbolt.org/z/sWw4vP. Extra parentheses are needed
// to workaround a bug in MSVC 2019 (see #1140 and #1186).
#define FMT_ENABLE_IF(...) enable_if_t<(__VA_ARGS__), int> = 0
namespace internal {
// A helper function to suppress bogus "conditional expression is constant"
// warnings.
template <typename T> FMT_CONSTEXPR T const_check(T value) { return value; }
// A workaround for gcc 4.8 to make void_t work in a SFINAE context.
template <typename... Ts> struct void_t_impl { using type = void; };
FMT_NORETURN FMT_API void assert_fail(const char* file, int line,
const char* message);
#ifndef FMT_ASSERT
# ifdef NDEBUG
// FMT_ASSERT is not empty to avoid -Werror=empty-body.
# define FMT_ASSERT(condition, message) ((void)0)
# else
# define FMT_ASSERT(condition, message) \
((condition) /* void() fails with -Winvalid-constexpr on clang 4.0.1 */ \
? (void)0 \
: ::fmt::internal::assert_fail(__FILE__, __LINE__, (message)))
# endif
#endif
#if defined(FMT_USE_STRING_VIEW)
template <typename Char> using std_string_view = std::basic_string_view<Char>;
#elif defined(FMT_USE_EXPERIMENTAL_STRING_VIEW)
template <typename Char>
using std_string_view = std::experimental::basic_string_view<Char>;
#else
template <typename T> struct std_string_view {};
#endif
#ifdef FMT_USE_INT128
// Do nothing.
#elif defined(__SIZEOF_INT128__) && !FMT_NVCC
# define FMT_USE_INT128 1
using int128_t = __int128_t;
using uint128_t = __uint128_t;
#else
# define FMT_USE_INT128 0
#endif
#if !FMT_USE_INT128
struct int128_t {};
struct uint128_t {};
#endif
// Casts a nonnegative integer to unsigned.
template <typename Int>
FMT_CONSTEXPR typename std::make_unsigned<Int>::type to_unsigned(Int value) {
FMT_ASSERT(value >= 0, "negative value");
return static_cast<typename std::make_unsigned<Int>::type>(value);
}
constexpr unsigned char micro[] = "\u00B5";
template <typename Char> constexpr bool is_unicode() {
return FMT_UNICODE || sizeof(Char) != 1 ||
(sizeof(micro) == 3 && micro[0] == 0xC2 && micro[1] == 0xB5);
}
#ifdef __cpp_char8_t
using char8_type = char8_t;
#else
enum char8_type : unsigned char {};
#endif
} // namespace internal
template <typename... Ts>
using void_t = typename internal::void_t_impl<Ts...>::type;
/**
An implementation of ``std::basic_string_view`` for pre-C++17. It provides a
subset of the API. ``fmt::basic_string_view`` is used for format strings even
if ``std::string_view`` is available to prevent issues when a library is
compiled with a different ``-std`` option than the client code (which is not
recommended).
*/
template <typename Char> class basic_string_view {
private:
const Char* data_;
size_t size_;
public:
using char_type FMT_DEPRECATED_ALIAS = Char;
using value_type = Char;
using iterator = const Char*;
FMT_CONSTEXPR basic_string_view() FMT_NOEXCEPT : data_(nullptr), size_(0) {}
/** Constructs a string reference object from a C string and a size. */
FMT_CONSTEXPR basic_string_view(const Char* s, size_t count) FMT_NOEXCEPT
: data_(s),
size_(count) {}
/**
\rst
Constructs a string reference object from a C string computing
the size with ``std::char_traits<Char>::length``.
\endrst
*/
#if __cplusplus >= 201703L // C++17's char_traits::length() is constexpr.
FMT_CONSTEXPR
#endif
basic_string_view(const Char* s)
: data_(s), size_(std::char_traits<Char>::length(s)) {}
/** Constructs a string reference from a ``std::basic_string`` object. */
template <typename Traits, typename Alloc>
FMT_CONSTEXPR basic_string_view(
const std::basic_string<Char, Traits, Alloc>& s) FMT_NOEXCEPT
: data_(s.data()),
size_(s.size()) {}
template <
typename S,
FMT_ENABLE_IF(std::is_same<S, internal::std_string_view<Char>>::value)>
FMT_CONSTEXPR basic_string_view(S s) FMT_NOEXCEPT : data_(s.data()),
size_(s.size()) {}
/** Returns a pointer to the string data. */
FMT_CONSTEXPR const Char* data() const { return data_; }
/** Returns the string size. */
FMT_CONSTEXPR size_t size() const { return size_; }
FMT_CONSTEXPR iterator begin() const { return data_; }
FMT_CONSTEXPR iterator end() const { return data_ + size_; }
FMT_CONSTEXPR const Char& operator[](size_t pos) const { return data_[pos]; }
FMT_CONSTEXPR void remove_prefix(size_t n) {
data_ += n;
size_ -= n;
}
// Lexicographically compare this string reference to other.
int compare(basic_string_view other) const {
size_t str_size = size_ < other.size_ ? size_ : other.size_;
int result = std::char_traits<Char>::compare(data_, other.data_, str_size);
if (result == 0)
result = size_ == other.size_ ? 0 : (size_ < other.size_ ? -1 : 1);
return result;
}
friend bool operator==(basic_string_view lhs, basic_string_view rhs) {
return lhs.compare(rhs) == 0;
}
friend bool operator!=(basic_string_view lhs, basic_string_view rhs) {
return lhs.compare(rhs) != 0;
}
friend bool operator<(basic_string_view lhs, basic_string_view rhs) {
return lhs.compare(rhs) < 0;
}
friend bool operator<=(basic_string_view lhs, basic_string_view rhs) {
return lhs.compare(rhs) <= 0;
}
friend bool operator>(basic_string_view lhs, basic_string_view rhs) {
return lhs.compare(rhs) > 0;
}
friend bool operator>=(basic_string_view lhs, basic_string_view rhs) {
return lhs.compare(rhs) >= 0;
}
};
using string_view = basic_string_view<char>;
using wstring_view = basic_string_view<wchar_t>;
#ifndef __cpp_char8_t
// char8_t is deprecated; use char instead.
using char8_t FMT_DEPRECATED_ALIAS = internal::char8_type;
#endif
/** Specifies if ``T`` is a character type. Can be specialized by users. */
template <typename T> struct is_char : std::false_type {};
template <> struct is_char<char> : std::true_type {};
template <> struct is_char<wchar_t> : std::true_type {};
template <> struct is_char<internal::char8_type> : std::true_type {};
template <> struct is_char<char16_t> : std::true_type {};
template <> struct is_char<char32_t> : std::true_type {};
/**
\rst
Returns a string view of `s`. In order to add custom string type support to
{fmt} provide an overload of `to_string_view` for it in the same namespace as
the type for the argument-dependent lookup to work.
**Example**::
namespace my_ns {
inline string_view to_string_view(const my_string& s) {
return {s.data(), s.length()};
}
}
std::string message = fmt::format(my_string("The answer is {}"), 42);
\endrst
*/
template <typename Char, FMT_ENABLE_IF(is_char<Char>::value)>
inline basic_string_view<Char> to_string_view(const Char* s) {
return s;
}
template <typename Char, typename Traits, typename Alloc>
inline basic_string_view<Char> to_string_view(
const std::basic_string<Char, Traits, Alloc>& s) {
return s;
}
template <typename Char>
inline basic_string_view<Char> to_string_view(basic_string_view<Char> s) {
return s;
}
template <typename Char,
FMT_ENABLE_IF(!std::is_empty<internal::std_string_view<Char>>::value)>
inline basic_string_view<Char> to_string_view(
internal::std_string_view<Char> s) {
return s;
}
// A base class for compile-time strings. It is defined in the fmt namespace to
// make formatting functions visible via ADL, e.g. format(fmt("{}"), 42).
struct compile_string {};
template <typename S>
struct is_compile_string : std::is_base_of<compile_string, S> {};
template <typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
constexpr basic_string_view<typename S::char_type> to_string_view(const S& s) {
return s;
}
namespace internal {
void to_string_view(...);
using fmt::v6::to_string_view;
// Specifies whether S is a string type convertible to fmt::basic_string_view.
// It should be a constexpr function but MSVC 2017 fails to compile it in
// enable_if and MSVC 2015 fails to compile it as an alias template.
template <typename S>
struct is_string : std::is_class<decltype(to_string_view(std::declval<S>()))> {
};
template <typename S, typename = void> struct char_t_impl {};
template <typename S> struct char_t_impl<S, enable_if_t<is_string<S>::value>> {
using result = decltype(to_string_view(std::declval<S>()));
using type = typename result::value_type;
};
struct error_handler {
FMT_CONSTEXPR error_handler() = default;
FMT_CONSTEXPR error_handler(const error_handler&) = default;
// This function is intentionally not constexpr to give a compile-time error.
FMT_NORETURN FMT_API void on_error(const char* message);
};
} // namespace internal
/** String's character type. */
template <typename S> using char_t = typename internal::char_t_impl<S>::type;
/**
\rst
Parsing context consisting of a format string range being parsed and an
argument counter for automatic indexing.
You can use one of the following type aliases for common character types:
+-----------------------+-------------------------------------+
| Type | Definition |
+=======================+=====================================+
| format_parse_context | basic_format_parse_context<char> |
+-----------------------+-------------------------------------+
| wformat_parse_context | basic_format_parse_context<wchar_t> |
+-----------------------+-------------------------------------+
\endrst
*/
template <typename Char, typename ErrorHandler = internal::error_handler>
class basic_format_parse_context : private ErrorHandler {
private:
basic_string_view<Char> format_str_;
int next_arg_id_;
public:
using char_type = Char;
using iterator = typename basic_string_view<Char>::iterator;
explicit FMT_CONSTEXPR basic_format_parse_context(
basic_string_view<Char> format_str, ErrorHandler eh = ErrorHandler())
: ErrorHandler(eh), format_str_(format_str), next_arg_id_(0) {}
/**
Returns an iterator to the beginning of the format string range being
parsed.
*/
FMT_CONSTEXPR iterator begin() const FMT_NOEXCEPT {
return format_str_.begin();
}
/**
Returns an iterator past the end of the format string range being parsed.
*/
FMT_CONSTEXPR iterator end() const FMT_NOEXCEPT { return format_str_.end(); }
/** Advances the begin iterator to ``it``. */
FMT_CONSTEXPR void advance_to(iterator it) {
format_str_.remove_prefix(internal::to_unsigned(it - begin()));
}
/**
Reports an error if using the manual argument indexing; otherwise returns
the next argument index and switches to the automatic indexing.
*/
FMT_CONSTEXPR int next_arg_id() {
if (next_arg_id_ >= 0) return next_arg_id_++;
on_error("cannot switch from manual to automatic argument indexing");
return 0;
}
/**
Reports an error if using the automatic argument indexing; otherwise
switches to the manual indexing.
*/
FMT_CONSTEXPR void check_arg_id(int) {
if (next_arg_id_ > 0)
on_error("cannot switch from automatic to manual argument indexing");
else
next_arg_id_ = -1;
}
FMT_CONSTEXPR void check_arg_id(basic_string_view<Char>) {}
FMT_CONSTEXPR void on_error(const char* message) {
ErrorHandler::on_error(message);
}
FMT_CONSTEXPR ErrorHandler error_handler() const { return *this; }
};
using format_parse_context = basic_format_parse_context<char>;
using wformat_parse_context = basic_format_parse_context<wchar_t>;
template <typename Char, typename ErrorHandler = internal::error_handler>
using basic_parse_context FMT_DEPRECATED_ALIAS =
basic_format_parse_context<Char, ErrorHandler>;
using parse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context<char>;
using wparse_context FMT_DEPRECATED_ALIAS = basic_format_parse_context<wchar_t>;
template <typename Context> class basic_format_arg;
template <typename Context> class basic_format_args;
// A formatter for objects of type T.
template <typename T, typename Char = char, typename Enable = void>
struct formatter {
// A deleted default constructor indicates a disabled formatter.
formatter() = delete;
};
template <typename T, typename Char, typename Enable = void>
struct FMT_DEPRECATED convert_to_int
: bool_constant<!std::is_arithmetic<T>::value &&
std::is_convertible<T, int>::value> {};
// Specifies if T has an enabled formatter specialization. A type can be
// formattable even if it doesn't have a formatter e.g. via a conversion.
template <typename T, typename Context>
using has_formatter =
std::is_constructible<typename Context::template formatter_type<T>>;
namespace internal {
/** A contiguous memory buffer with an optional growing ability. */
template <typename T> class buffer {
private:
T* ptr_;
std::size_t size_;
std::size_t capacity_;
protected:
// Don't initialize ptr_ since it is not accessed to save a few cycles.
buffer(std::size_t sz) FMT_NOEXCEPT : size_(sz), capacity_(sz) {}
buffer(T* p = nullptr, std::size_t sz = 0, std::size_t cap = 0) FMT_NOEXCEPT
: ptr_(p),
size_(sz),
capacity_(cap) {}
/** Sets the buffer data and capacity. */
void set(T* buf_data, std::size_t buf_capacity) FMT_NOEXCEPT {
ptr_ = buf_data;
capacity_ = buf_capacity;
}
/** Increases the buffer capacity to hold at least *capacity* elements. */
virtual void grow(std::size_t capacity) = 0;
public:
using value_type = T;
using const_reference = const T&;
buffer(const buffer&) = delete;
void operator=(const buffer&) = delete;
virtual ~buffer() = default;
T* begin() FMT_NOEXCEPT { return ptr_; }
T* end() FMT_NOEXCEPT { return ptr_ + size_; }
const T* begin() const FMT_NOEXCEPT { return ptr_; }
const T* end() const FMT_NOEXCEPT { return ptr_ + size_; }
/** Returns the size of this buffer. */
std::size_t size() const FMT_NOEXCEPT { return size_; }
/** Returns the capacity of this buffer. */
std::size_t capacity() const FMT_NOEXCEPT { return capacity_; }
/** Returns a pointer to the buffer data. */
T* data() FMT_NOEXCEPT { return ptr_; }
/** Returns a pointer to the buffer data. */
const T* data() const FMT_NOEXCEPT { return ptr_; }
/**
Resizes the buffer. If T is a POD type new elements may not be initialized.
*/
void resize(std::size_t new_size) {
reserve(new_size);
size_ = new_size;
}
/** Clears this buffer. */
void clear() { size_ = 0; }
/** Reserves space to store at least *capacity* elements. */
void reserve(std::size_t new_capacity) {
if (new_capacity > capacity_) grow(new_capacity);
}
void push_back(const T& value) {
reserve(size_ + 1);
ptr_[size_++] = value;
}
/** Appends data to the end of the buffer. */
template <typename U> void append(const U* begin, const U* end);
template <typename I> T& operator[](I index) { return ptr_[index]; }
template <typename I> const T& operator[](I index) const {
return ptr_[index];
}
};
// A container-backed buffer.
template <typename Container>
class container_buffer : public buffer<typename Container::value_type> {
private:
Container& container_;
protected:
void grow(std::size_t capacity) FMT_OVERRIDE {
container_.resize(capacity);
this->set(&container_[0], capacity);
}
public:
explicit container_buffer(Container& c)
: buffer<typename Container::value_type>(c.size()), container_(c) {}
};
// Extracts a reference to the container from back_insert_iterator.
template <typename Container>
inline Container& get_container(std::back_insert_iterator<Container> it) {
using bi_iterator = std::back_insert_iterator<Container>;
struct accessor : bi_iterator {
accessor(bi_iterator iter) : bi_iterator(iter) {}
using bi_iterator::container;
};
return *accessor(it).container;
}
template <typename T, typename Char = char, typename Enable = void>
struct fallback_formatter {
fallback_formatter() = delete;
};
// Specifies if T has an enabled fallback_formatter specialization.
template <typename T, typename Context>
using has_fallback_formatter =
std::is_constructible<fallback_formatter<T, typename Context::char_type>>;
template <typename Char> struct named_arg_base;
template <typename T, typename Char> struct named_arg;
enum class type {
none_type,
named_arg_type,
// Integer types should go first,
int_type,
uint_type,
long_long_type,
ulong_long_type,
int128_type,
uint128_type,
bool_type,
char_type,
last_integer_type = char_type,
// followed by floating-point types.
float_type,
double_type,
long_double_type,
last_numeric_type = long_double_type,
cstring_type,
string_type,
pointer_type,
custom_type
};
// Maps core type T to the corresponding type enum constant.
template <typename T, typename Char>
struct type_constant : std::integral_constant<type, type::custom_type> {};
#define FMT_TYPE_CONSTANT(Type, constant) \
template <typename Char> \
struct type_constant<Type, Char> \
: std::integral_constant<type, type::constant> {}
FMT_TYPE_CONSTANT(const named_arg_base<Char>&, named_arg_type);
FMT_TYPE_CONSTANT(int, int_type);
FMT_TYPE_CONSTANT(unsigned, uint_type);
FMT_TYPE_CONSTANT(long long, long_long_type);
FMT_TYPE_CONSTANT(unsigned long long, ulong_long_type);
FMT_TYPE_CONSTANT(int128_t, int128_type);
FMT_TYPE_CONSTANT(uint128_t, uint128_type);
FMT_TYPE_CONSTANT(bool, bool_type);
FMT_TYPE_CONSTANT(Char, char_type);
FMT_TYPE_CONSTANT(float, float_type);
FMT_TYPE_CONSTANT(double, double_type);
FMT_TYPE_CONSTANT(long double, long_double_type);
FMT_TYPE_CONSTANT(const Char*, cstring_type);
FMT_TYPE_CONSTANT(basic_string_view<Char>, string_type);
FMT_TYPE_CONSTANT(const void*, pointer_type);
FMT_CONSTEXPR bool is_integral_type(type t) {
FMT_ASSERT(t != type::named_arg_type, "invalid argument type");
return t > type::none_type && t <= type::last_integer_type;
}
FMT_CONSTEXPR bool is_arithmetic_type(type t) {
FMT_ASSERT(t != type::named_arg_type, "invalid argument type");
return t > type::none_type && t <= type::last_numeric_type;
}
template <typename Char> struct string_value {
const Char* data;
std::size_t size;
};
template <typename Context> struct custom_value {
using parse_context = basic_format_parse_context<typename Context::char_type>;
const void* value;
void (*format)(const void* arg, parse_context& parse_ctx, Context& ctx);
};
// A formatting argument value.
template <typename Context> class value {
public:
using char_type = typename Context::char_type;
union {
int int_value;
unsigned uint_value;
long long long_long_value;
unsigned long long ulong_long_value;
int128_t int128_value;
uint128_t uint128_value;
bool bool_value;
char_type char_value;
float float_value;
double double_value;
long double long_double_value;
const void* pointer;
string_value<char_type> string;
custom_value<Context> custom;
const named_arg_base<char_type>* named_arg;
};
FMT_CONSTEXPR value(int val = 0) : int_value(val) {}
FMT_CONSTEXPR value(unsigned val) : uint_value(val) {}
value(long long val) : long_long_value(val) {}
value(unsigned long long val) : ulong_long_value(val) {}
value(int128_t val) : int128_value(val) {}
value(uint128_t val) : uint128_value(val) {}
value(float val) : float_value(val) {}
value(double val) : double_value(val) {}
value(long double val) : long_double_value(val) {}
value(bool val) : bool_value(val) {}
value(char_type val) : char_value(val) {}
value(const char_type* val) { string.data = val; }
value(basic_string_view<char_type> val) {
string.data = val.data();
string.size = val.size();
}
value(const void* val) : pointer(val) {}
template <typename T> value(const T& val) {
custom.value = &val;
// Get the formatter type through the context to allow different contexts
// have different extension points, e.g. `formatter<T>` for `format` and
// `printf_formatter<T>` for `printf`.
custom.format = format_custom_arg<
T, conditional_t<has_formatter<T, Context>::value,
typename Context::template formatter_type<T>,
fallback_formatter<T, char_type>>>;
}
value(const named_arg_base<char_type>& val) { named_arg = &val; }
private:
// Formats an argument of a custom type, such as a user-defined class.
template <typename T, typename Formatter>
static void format_custom_arg(
const void* arg, basic_format_parse_context<char_type>& parse_ctx,
Context& ctx) {
Formatter f;
parse_ctx.advance_to(f.parse(parse_ctx));
ctx.advance_to(f.format(*static_cast<const T*>(arg), ctx));
}
};
template <typename Context, typename T>
FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value);
// To minimize the number of types we need to deal with, long is translated
// either to int or to long long depending on its size.
enum { long_short = sizeof(long) == sizeof(int) };
using long_type = conditional_t<long_short, int, long long>;
using ulong_type = conditional_t<long_short, unsigned, unsigned long long>;
// Maps formatting arguments to core types.
template <typename Context> struct arg_mapper {
using char_type = typename Context::char_type;
FMT_CONSTEXPR int map(signed char val) { return val; }
FMT_CONSTEXPR unsigned map(unsigned char val) { return val; }
FMT_CONSTEXPR int map(short val) { return val; }
FMT_CONSTEXPR unsigned map(unsigned short val) { return val; }
FMT_CONSTEXPR int map(int val) { return val; }
FMT_CONSTEXPR unsigned map(unsigned val) { return val; }
FMT_CONSTEXPR long_type map(long val) { return val; }
FMT_CONSTEXPR ulong_type map(unsigned long val) { return val; }
FMT_CONSTEXPR long long map(long long val) { return val; }
FMT_CONSTEXPR unsigned long long map(unsigned long long val) { return val; }
FMT_CONSTEXPR int128_t map(int128_t val) { return val; }
FMT_CONSTEXPR uint128_t map(uint128_t val) { return val; }
FMT_CONSTEXPR bool map(bool val) { return val; }
template <typename T, FMT_ENABLE_IF(is_char<T>::value)>
FMT_CONSTEXPR char_type map(T val) {
static_assert(
std::is_same<T, char>::value || std::is_same<T, char_type>::value,
"mixing character types is disallowed");
return val;
}
FMT_CONSTEXPR float map(float val) { return val; }
FMT_CONSTEXPR double map(double val) { return val; }
FMT_CONSTEXPR long double map(long double val) { return val; }
FMT_CONSTEXPR const char_type* map(char_type* val) { return val; }
FMT_CONSTEXPR const char_type* map(const char_type* val) { return val; }
template <typename T, FMT_ENABLE_IF(is_string<T>::value)>
FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
static_assert(std::is_same<char_type, char_t<T>>::value,
"mixing character types is disallowed");
return to_string_view(val);
}
template <typename T,
FMT_ENABLE_IF(
std::is_constructible<basic_string_view<char_type>, T>::value &&
!is_string<T>::value && !has_formatter<T, Context>::value &&
!has_fallback_formatter<T, Context>::value)>
FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
return basic_string_view<char_type>(val);
}
template <
typename T,
FMT_ENABLE_IF(
std::is_constructible<std_string_view<char_type>, T>::value &&
!std::is_constructible<basic_string_view<char_type>, T>::value &&
!is_string<T>::value && !has_formatter<T, Context>::value &&
!has_fallback_formatter<T, Context>::value)>
FMT_CONSTEXPR basic_string_view<char_type> map(const T& val) {
return std_string_view<char_type>(val);
}
FMT_CONSTEXPR const char* map(const signed char* val) {
static_assert(std::is_same<char_type, char>::value, "invalid string type");
return reinterpret_cast<const char*>(val);
}
FMT_CONSTEXPR const char* map(const unsigned char* val) {
static_assert(std::is_same<char_type, char>::value, "invalid string type");
return reinterpret_cast<const char*>(val);
}
FMT_CONSTEXPR const void* map(void* val) { return val; }
FMT_CONSTEXPR const void* map(const void* val) { return val; }
FMT_CONSTEXPR const void* map(std::nullptr_t val) { return val; }
template <typename T> FMT_CONSTEXPR int map(const T*) {
// Formatting of arbitrary pointers is disallowed. If you want to output
// a pointer cast it to "void *" or "const void *". In particular, this
// forbids formatting of "[const] volatile char *" which is printed as bool
// by iostreams.
static_assert(!sizeof(T), "formatting of non-void pointers is disallowed");
return 0;
}
template <typename T,
FMT_ENABLE_IF(std::is_enum<T>::value &&
!has_formatter<T, Context>::value &&
!has_fallback_formatter<T, Context>::value)>
FMT_CONSTEXPR auto map(const T& val)
-> decltype(std::declval<arg_mapper>().map(
static_cast<typename std::underlying_type<T>::type>(val))) {
return map(static_cast<typename std::underlying_type<T>::type>(val));
}
template <typename T,
FMT_ENABLE_IF(!is_string<T>::value && !is_char<T>::value &&
(has_formatter<T, Context>::value ||
has_fallback_formatter<T, Context>::value))>
FMT_CONSTEXPR const T& map(const T& val) {
return val;
}
template <typename T>
FMT_CONSTEXPR const named_arg_base<char_type>& map(
const named_arg<T, char_type>& val) {
auto arg = make_arg<Context>(val.value);
std::memcpy(val.data, &arg, sizeof(arg));
return val;
}
int map(...) {
constexpr bool formattable = sizeof(Context) == 0;
static_assert(
formattable,
"Cannot format argument. To make type T formattable provide a "
"formatter<T> specialization: "
"https://fmt.dev/latest/api.html#formatting-user-defined-types");
return 0;
}
};
// A type constant after applying arg_mapper<Context>.
template <typename T, typename Context>
using mapped_type_constant =
type_constant<decltype(arg_mapper<Context>().map(std::declval<const T&>())),
typename Context::char_type>;
enum { packed_arg_bits = 5 };
// Maximum number of arguments with packed types.
enum { max_packed_args = 63 / packed_arg_bits };
enum : unsigned long long { is_unpacked_bit = 1ULL << 63 };
template <typename Context> class arg_map;
} // namespace internal
// A formatting argument. It is a trivially copyable/constructible type to
// allow storage in basic_memory_buffer.
template <typename Context> class basic_format_arg {
private:
internal::value<Context> value_;
internal::type type_;
template <typename ContextType, typename T>
friend FMT_CONSTEXPR basic_format_arg<ContextType> internal::make_arg(
const T& value);
template <typename Visitor, typename Ctx>
friend FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
const basic_format_arg<Ctx>& arg)
-> decltype(vis(0));
friend class basic_format_args<Context>;
friend class internal::arg_map<Context>;
using char_type = typename Context::char_type;
public:
class handle {
public:
explicit handle(internal::custom_value<Context> custom) : custom_(custom) {}
void format(basic_format_parse_context<char_type>& parse_ctx,
Context& ctx) const {
custom_.format(custom_.value, parse_ctx, ctx);
}
private:
internal::custom_value<Context> custom_;
};
FMT_CONSTEXPR basic_format_arg() : type_(internal::type::none_type) {}
FMT_CONSTEXPR explicit operator bool() const FMT_NOEXCEPT {
return type_ != internal::type::none_type;
}
internal::type type() const { return type_; }
bool is_integral() const { return internal::is_integral_type(type_); }
bool is_arithmetic() const { return internal::is_arithmetic_type(type_); }
};
/**
\rst
Visits an argument dispatching to the appropriate visit method based on
the argument type. For example, if the argument type is ``double`` then
``vis(value)`` will be called with the value of type ``double``.
\endrst
*/
template <typename Visitor, typename Context>
FMT_CONSTEXPR auto visit_format_arg(Visitor&& vis,
const basic_format_arg<Context>& arg)
-> decltype(vis(0)) {
using char_type = typename Context::char_type;
switch (arg.type_) {
case internal::type::none_type:
break;
case internal::type::named_arg_type:
FMT_ASSERT(false, "invalid argument type");
break;
case internal::type::int_type:
return vis(arg.value_.int_value);
case internal::type::uint_type:
return vis(arg.value_.uint_value);
case internal::type::long_long_type:
return vis(arg.value_.long_long_value);
case internal::type::ulong_long_type:
return vis(arg.value_.ulong_long_value);
#if FMT_USE_INT128
case internal::type::int128_type:
return vis(arg.value_.int128_value);
case internal::type::uint128_type:
return vis(arg.value_.uint128_value);
#else
case internal::type::int128_type:
case internal::type::uint128_type:
break;
#endif
case internal::type::bool_type:
return vis(arg.value_.bool_value);
case internal::type::char_type:
return vis(arg.value_.char_value);
case internal::type::float_type:
return vis(arg.value_.float_value);
case internal::type::double_type:
return vis(arg.value_.double_value);
case internal::type::long_double_type:
return vis(arg.value_.long_double_value);
case internal::type::cstring_type:
return vis(arg.value_.string.data);
case internal::type::string_type:
return vis(basic_string_view<char_type>(arg.value_.string.data,
arg.value_.string.size));
case internal::type::pointer_type:
return vis(arg.value_.pointer);
case internal::type::custom_type:
return vis(typename basic_format_arg<Context>::handle(arg.value_.custom));
}
return vis(monostate());
}
namespace internal {
// A map from argument names to their values for named arguments.
template <typename Context> class arg_map {
private:
using char_type = typename Context::char_type;
struct entry {
basic_string_view<char_type> name;
basic_format_arg<Context> arg;
};
entry* map_;
unsigned size_;
void push_back(value<Context> val) {
const auto& named = *val.named_arg;
map_[size_] = {named.name, named.template deserialize<Context>()};
++size_;
}
public:
arg_map(const arg_map&) = delete;
void operator=(const arg_map&) = delete;
arg_map() : map_(nullptr), size_(0) {}
void init(const basic_format_args<Context>& args);
~arg_map() { delete[] map_; }
basic_format_arg<Context> find(basic_string_view<char_type> name) const {
// The list is unsorted, so just return the first matching name.
for (entry *it = map_, *end = map_ + size_; it != end; ++it) {
if (it->name == name) return it->arg;
}
return {};
}
};
// A type-erased reference to an std::locale to avoid heavy <locale> include.
class locale_ref {
private:
const void* locale_; // A type-erased pointer to std::locale.
public:
locale_ref() : locale_(nullptr) {}
template <typename Locale> explicit locale_ref(const Locale& loc);
explicit operator bool() const FMT_NOEXCEPT { return locale_ != nullptr; }
template <typename Locale> Locale get() const;
};
template <typename> constexpr unsigned long long encode_types() { return 0; }
template <typename Context, typename Arg, typename... Args>
constexpr unsigned long long encode_types() {
return static_cast<unsigned>(mapped_type_constant<Arg, Context>::value) |
(encode_types<Context, Args...>() << packed_arg_bits);
}
template <typename Context, typename T>
FMT_CONSTEXPR basic_format_arg<Context> make_arg(const T& value) {
basic_format_arg<Context> arg;
arg.type_ = mapped_type_constant<T, Context>::value;
arg.value_ = arg_mapper<Context>().map(value);
return arg;
}
template <bool IS_PACKED, typename Context, typename T,
FMT_ENABLE_IF(IS_PACKED)>
inline value<Context> make_arg(const T& val) {
return arg_mapper<Context>().map(val);
}
template <bool IS_PACKED, typename Context, typename T,
FMT_ENABLE_IF(!IS_PACKED)>
inline basic_format_arg<Context> make_arg(const T& value) {
return make_arg<Context>(value);
}
template <typename T> struct is_reference_wrapper : std::false_type {};
template <typename T>
struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
class dynamic_arg_list {
// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
// templates it doesn't complain about inability to deduce single translation
// unit for placing vtable. So storage_node_base is made a fake template.
template <typename = void> struct node {
virtual ~node() = default;
std::unique_ptr<node<>> next;
};
template <typename T> struct typed_node : node<> {
T value;
template <typename Arg>
FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
template <typename Char>
FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
: value(arg.data(), arg.size()) {}
};
std::unique_ptr<node<>> head_;
public:
template <typename T, typename Arg> const T& push(const Arg& arg) {
auto node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
auto& value = node->value;
node->next = std::move(head_);
head_ = std::move(node);
return value;
}
};
} // namespace internal
// Formatting context.
template <typename OutputIt, typename Char> class basic_format_context {
public:
/** The character type for the output. */
using char_type = Char;
private:
OutputIt out_;
basic_format_args<basic_format_context> args_;
internal::arg_map<basic_format_context> map_;
internal::locale_ref loc_;
public:
using iterator = OutputIt;
using format_arg = basic_format_arg<basic_format_context>;
template <typename T> using formatter_type = formatter<T, char_type>;
basic_format_context(const basic_format_context&) = delete;
void operator=(const basic_format_context&) = delete;
/**
Constructs a ``basic_format_context`` object. References to the arguments are
stored in the object so make sure they have appropriate lifetimes.
*/
basic_format_context(OutputIt out,
basic_format_args<basic_format_context> ctx_args,
internal::locale_ref loc = internal::locale_ref())
: out_(out), args_(ctx_args), loc_(loc) {}
format_arg arg(int id) const { return args_.get(id); }
// Checks if manual indexing is used and returns the argument with the
// specified name.
format_arg arg(basic_string_view<char_type> name);
internal::error_handler error_handler() { return {}; }
void on_error(const char* message) { error_handler().on_error(message); }
// Returns an iterator to the beginning of the output range.
iterator out() { return out_; }
// Advances the begin iterator to ``it``.
void advance_to(iterator it) { out_ = it; }
internal::locale_ref locale() { return loc_; }
};
template <typename Char>
using buffer_context =
basic_format_context<std::back_insert_iterator<internal::buffer<Char>>,
Char>;
using format_context = buffer_context<char>;
using wformat_context = buffer_context<wchar_t>;
/**
\rst
An array of references to arguments. It can be implicitly converted into
`~fmt::basic_format_args` for passing into type-erased formatting functions
such as `~fmt::vformat`.
\endrst
*/
template <typename Context, typename... Args>
class format_arg_store
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
// Workaround a GCC template argument substitution bug.
: public basic_format_args<Context>
#endif
{
private:
static const size_t num_args = sizeof...(Args);
static const bool is_packed = num_args < internal::max_packed_args;
using value_type = conditional_t<is_packed, internal::value<Context>,
basic_format_arg<Context>>;
// If the arguments are not packed, add one more element to mark the end.
value_type data_[num_args + (num_args == 0 ? 1 : 0)];
friend class basic_format_args<Context>;
public:
static constexpr unsigned long long types =
is_packed ? internal::encode_types<Context, Args...>()
: internal::is_unpacked_bit | num_args;
format_arg_store(const Args&... args)
:
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
basic_format_args<Context>(*this),
#endif
data_{internal::make_arg<is_packed, Context>(args)...} {
}
};
/**
\rst
Constructs an `~fmt::format_arg_store` object that contains references to
arguments and can be implicitly converted to `~fmt::format_args`. `Context`
can be omitted in which case it defaults to `~fmt::context`.
See `~fmt::arg` for lifetime considerations.
\endrst
*/
template <typename Context = format_context, typename... Args>
inline format_arg_store<Context, Args...> make_format_args(
const Args&... args) {
return {args...};
}
/**
\rst
A dynamic version of `fmt::format_arg_store<>`.
It's equipped with a storage to potentially temporary objects which lifetime
could be shorter than the format arguments object.
It can be implicitly converted into `~fmt::basic_format_args` for passing
into type-erased formatting functions such as `~fmt::vformat`.
\endrst
*/
template <typename Context>
class dynamic_format_arg_store
#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
// Workaround a GCC template argument substitution bug.
: public basic_format_args<Context>
#endif
{
private:
using char_type = typename Context::char_type;
template <typename T> struct need_copy {
static constexpr internal::type mapped_type =
internal::mapped_type_constant<T, Context>::value;
enum {
value = !(internal::is_reference_wrapper<T>::value ||
std::is_same<T, basic_string_view<char_type>>::value ||
std::is_same<T, internal::std_string_view<char_type>>::value ||
(mapped_type != internal::type::cstring_type &&
mapped_type != internal::type::string_type &&
mapped_type != internal::type::custom_type &&
mapped_type != internal::type::named_arg_type))
};
};
template <typename T>
using stored_type = conditional_t<internal::is_string<T>::value,
std::basic_string<char_type>, T>;
// Storage of basic_format_arg must be contiguous.
std::vector<basic_format_arg<Context>> data_;
// Storage of arguments not fitting into basic_format_arg must grow
// without relocation because items in data_ refer to it.
internal::dynamic_arg_list dynamic_args_;
friend class basic_format_args<Context>;
unsigned long long get_types() const {
return internal::is_unpacked_bit | data_.size();
}
template <typename T> void emplace_arg(const T& arg) {
data_.emplace_back(internal::make_arg<Context>(arg));
}
public:
/**
\rst
Adds an argument into the dynamic store for later passing to a formating
function.
Note that custom types and string types (but not string views!) are copied
into the store with dynamic memory (in addition to resizing vector).
**Example**::
fmt::dynamic_format_arg_store<fmt::format_context> store;
store.push_back(42);
store.push_back("abc");
store.push_back(1.5f);
std::string result = fmt::vformat("{} and {} and {}", store);
\endrst
*/
template <typename T> void push_back(const T& arg) {
static_assert(
!std::is_base_of<internal::named_arg_base<char_type>, T>::value,
"named arguments are not supported yet");
if (internal::const_check(need_copy<T>::value))
emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
else
emplace_arg(arg);
}
/**
Adds a reference to the argument into the dynamic store for later passing to
a formating function.
*/
template <typename T> void push_back(std::reference_wrapper<T> arg) {
static_assert(
need_copy<T>::value,
"objects of built-in types and string views are always copied");
emplace_arg(arg.get());
}
};
/**
\rst
A view of a collection of formatting arguments. To avoid lifetime issues it
should only be used as a parameter type in type-erased functions such as
``vformat``::
void vlog(string_view format_str, format_args args); // OK
format_args args = make_format_args(42); // Error: dangling reference
\endrst
*/
template <typename Context> class basic_format_args {
public:
using size_type = int;
using format_arg = basic_format_arg<Context>;
private:
// To reduce compiled code size per formatting function call, types of first
// max_packed_args arguments are passed in the types_ field.
unsigned long long types_;
union {
// If the number of arguments is less than max_packed_args, the argument
// values are stored in values_, otherwise they are stored in args_.
// This is done to reduce compiled code size as storing larger objects
// may require more code (at least on x86-64) even if the same amount of
// data is actually copied to stack. It saves ~10% on the bloat test.
const internal::value<Context>* values_;
const format_arg* args_;
};
bool is_packed() const { return (types_ & internal::is_unpacked_bit) == 0; }
internal::type type(int index) const {
int shift = index * internal::packed_arg_bits;
unsigned int mask = (1 << internal::packed_arg_bits) - 1;
return static_cast<internal::type>((types_ >> shift) & mask);
}
friend class internal::arg_map<Context>;
void set_data(const internal::value<Context>* values) { values_ = values; }
void set_data(const format_arg* args) { args_ = args; }
format_arg do_get(int index) const {
format_arg arg;
if (!is_packed()) {
auto num_args = max_size();
if (index < num_args) arg = args_[index];
return arg;
}
if (index > internal::max_packed_args) return arg;
arg.type_ = type(index);
if (arg.type_ == internal::type::none_type) return arg;
internal::value<Context>& val = arg.value_;
val = values_[index];
return arg;
}
public:
basic_format_args() : types_(0) {}
/**
\rst
Constructs a `basic_format_args` object from `~fmt::format_arg_store`.
\endrst
*/
template <typename... Args>
basic_format_args(const format_arg_store<Context, Args...>& store)
: types_(store.types) {
set_data(store.data_);
}
/**
\rst
Constructs a `basic_format_args` object from
`~fmt::dynamic_format_arg_store`.
\endrst
*/
basic_format_args(const dynamic_format_arg_store<Context>& store)
: types_(store.get_types()) {
set_data(store.data_.data());
}
/**
\rst
Constructs a `basic_format_args` object from a dynamic set of arguments.
\endrst
*/
basic_format_args(const format_arg* args, int count)
: types_(internal::is_unpacked_bit | internal::to_unsigned(count)) {
set_data(args);
}
/** Returns the argument at specified index. */
format_arg get(int index) const {
format_arg arg = do_get(index);
if (arg.type_ == internal::type::named_arg_type)
arg = arg.value_.named_arg->template deserialize<Context>();
return arg;
}
int max_size() const {
unsigned long long max_packed = internal::max_packed_args;
return static_cast<int>(is_packed() ? max_packed
: types_ & ~internal::is_unpacked_bit);
}
};
/** An alias to ``basic_format_args<context>``. */
// It is a separate type rather than an alias to make symbols readable.
struct format_args : basic_format_args<format_context> {
template <typename... Args>
format_args(Args&&... args)
: basic_format_args<format_context>(static_cast<Args&&>(args)...) {}
};
struct wformat_args : basic_format_args<wformat_context> {
template <typename... Args>
wformat_args(Args&&... args)
: basic_format_args<wformat_context>(static_cast<Args&&>(args)...) {}
};
template <typename Container> struct is_contiguous : std::false_type {};
template <typename Char>
struct is_contiguous<std::basic_string<Char>> : std::true_type {};
template <typename Char>
struct is_contiguous<internal::buffer<Char>> : std::true_type {};
namespace internal {
template <typename OutputIt>
struct is_contiguous_back_insert_iterator : std::false_type {};
template <typename Container>
struct is_contiguous_back_insert_iterator<std::back_insert_iterator<Container>>
: is_contiguous<Container> {};
template <typename Char> struct named_arg_base {
basic_string_view<Char> name;
// Serialized value<context>.
mutable char data[sizeof(basic_format_arg<buffer_context<Char>>)];
named_arg_base(basic_string_view<Char> nm) : name(nm) {}
template <typename Context> basic_format_arg<Context> deserialize() const {
basic_format_arg<Context> arg;
std::memcpy(&arg, data, sizeof(basic_format_arg<Context>));
return arg;
}
};
struct view {};
template <typename T, typename Char>
struct named_arg : view, named_arg_base<Char> {
const T& value;
named_arg(basic_string_view<Char> name, const T& val)
: named_arg_base<Char>(name), value(val) {}
};
template <typename..., typename S, FMT_ENABLE_IF(!is_compile_string<S>::value)>
inline void check_format_string(const S&) {
#if defined(FMT_ENFORCE_COMPILE_STRING)
static_assert(is_compile_string<S>::value,
"FMT_ENFORCE_COMPILE_STRING requires all format strings to "
"utilize FMT_STRING() or fmt().");
#endif
}
template <typename..., typename S, FMT_ENABLE_IF(is_compile_string<S>::value)>
void check_format_string(S);
template <bool...> struct bool_pack;
template <bool... Args>
using all_true =
std::is_same<bool_pack<Args..., true>, bool_pack<true, Args...>>;
template <typename... Args, typename S, typename Char = char_t<S>>
inline format_arg_store<buffer_context<Char>, remove_reference_t<Args>...>
make_args_checked(const S& format_str,
const remove_reference_t<Args>&... args) {
static_assert(
all_true<(!std::is_base_of<view, remove_reference_t<Args>>::value ||
!std::is_reference<Args>::value)...>::value,
"passing views as lvalues is disallowed");
check_format_string<Args...>(format_str);
return {args...};
}
template <typename Char>
std::basic_string<Char> vformat(
basic_string_view<Char> format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args);
template <typename Char>
typename buffer_context<Char>::iterator vformat_to(
buffer<Char>& buf, basic_string_view<Char> format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args);
template <typename Char, typename Args,
FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
inline void vprint_mojibake(std::FILE*, basic_string_view<Char>, const Args&) {}
FMT_API void vprint_mojibake(std::FILE*, string_view, format_args);
#ifndef _WIN32
inline void vprint_mojibake(std::FILE*, string_view, format_args) {}
#endif
} // namespace internal
/**
\rst
Returns a named argument to be used in a formatting function. It should only
be used in a call to a formatting function.
**Example**::
fmt::print("Elapsed time: {s:.2f} seconds", fmt::arg("s", 1.23));
\endrst
*/
template <typename S, typename T, typename Char = char_t<S>>
inline internal::named_arg<T, Char> arg(const S& name, const T& arg) {
static_assert(internal::is_string<S>::value, "");
return {name, arg};
}
// Disable nested named arguments, e.g. ``arg("a", arg("b", 42))``.
template <typename S, typename T, typename Char>
void arg(S, internal::named_arg<T, Char>) = delete;
/** Formats a string and writes the output to ``out``. */
// GCC 8 and earlier cannot handle std::back_insert_iterator<Container> with
// vformat_to<ArgFormatter>(...) overload, so SFINAE on iterator type instead.
template <typename OutputIt, typename S, typename Char = char_t<S>,
FMT_ENABLE_IF(
internal::is_contiguous_back_insert_iterator<OutputIt>::value)>
OutputIt vformat_to(
OutputIt out, const S& format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
using container = remove_reference_t<decltype(internal::get_container(out))>;
internal::container_buffer<container> buf((internal::get_container(out)));
internal::vformat_to(buf, to_string_view(format_str), args);
return out;
}
template <typename Container, typename S, typename... Args,
FMT_ENABLE_IF(
is_contiguous<Container>::value&& internal::is_string<S>::value)>
inline std::back_insert_iterator<Container> format_to(
std::back_insert_iterator<Container> out, const S& format_str,
Args&&... args) {
return vformat_to(out, to_string_view(format_str),
internal::make_args_checked<Args...>(format_str, args...));
}
template <typename S, typename Char = char_t<S>>
inline std::basic_string<Char> vformat(
const S& format_str,
basic_format_args<buffer_context<type_identity_t<Char>>> args) {
return internal::vformat(to_string_view(format_str), args);
}
/**
\rst
Formats arguments and returns the result as a string.
**Example**::
#include <fmt/core.h>
std::string message = fmt::format("The answer is {}", 42);
\endrst
*/
// Pass char_t as a default template parameter instead of using
// std::basic_string<char_t<S>> to reduce the symbol size.
template <typename S, typename... Args, typename Char = char_t<S>>
inline std::basic_string<Char> format(const S& format_str, Args&&... args) {
return internal::vformat(
to_string_view(format_str),
internal::make_args_checked<Args...>(format_str, args...));
}
FMT_API void vprint(string_view, format_args);
FMT_API void vprint(std::FILE*, string_view, format_args);
/**
\rst
Formats ``args`` according to specifications in ``format_str`` and writes the
output to the file ``f``. Strings are assumed to be Unicode-encoded unless the
``FMT_UNICODE`` macro is set to 0.
**Example**::
fmt::print(stderr, "Don't {}!", "panic");
\endrst
*/
template <typename S, typename... Args, typename Char = char_t<S>>
inline void print(std::FILE* f, const S& format_str, Args&&... args) {
return internal::is_unicode<Char>()
? vprint(f, to_string_view(format_str),
internal::make_args_checked<Args...>(format_str, args...))
: internal::vprint_mojibake(
f, to_string_view(format_str),
internal::make_args_checked<Args...>(format_str, args...));
}
/**
\rst
Formats ``args`` according to specifications in ``format_str`` and writes
the output to ``stdout``. Strings are assumed to be Unicode-encoded unless
the ``FMT_UNICODE`` macro is set to 0.
**Example**::
fmt::print("Elapsed time: {0:.2f} seconds", 1.23);
\endrst
*/
template <typename S, typename... Args, typename Char = char_t<S>>
inline void print(const S& format_str, Args&&... args) {
return internal::is_unicode<Char>()
? vprint(to_string_view(format_str),
internal::make_args_checked<Args...>(format_str, args...))
: internal::vprint_mojibake(
stdout, to_string_view(format_str),
internal::make_args_checked<Args...>(format_str, args...));
}
FMT_END_NAMESPACE
#endif // FMT_CORE_H_
================================================
FILE: examples/lesson04/fig04_12/fmt/format-inl.h
================================================
// Formatting library for C++ - implementation
//
// Copyright (c) 2012 - 2016, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
#ifndef FMT_FORMAT_INL_H_
#define FMT_FORMAT_INL_H_
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdarg>
#include <cstring> // for std::memmove
#include <cwchar>
#include "format.h"
#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
# include <locale>
#endif
#ifdef _WIN32
# include <io.h>
# include <windows.h>
#endif
#ifdef _MSC_VER
# pragma warning(push)
# pragma warning(disable : 4702) // unreachable code
#endif
// Dummy implementations of strerror_r and strerror_s called if corresponding
// system functions are not available.
inline fmt::internal::null<> strerror_r(int, char*, ...) { return {}; }
inline fmt::internal::null<> strerror_s(char*, std::size_t, ...) { return {}; }
FMT_BEGIN_NAMESPACE
namespace internal {
FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
print(stderr, "{}:{}: assertion failed: {}", file, line, message);
std::abort();
}
#ifndef _MSC_VER
# define FMT_SNPRINTF snprintf
#else // _MSC_VER
inline int fmt_snprintf(char* buffer, size_t size, const char* format, ...) {
va_list args;
va_start(args, format);
int result = vsnprintf_s(buffer, size, _TRUNCATE, format, args);
va_end(args);
return result;
}
# define FMT_SNPRINTF fmt_snprintf
#endif // _MSC_VER
// A portable thread-safe version of strerror.
// Sets buffer to point to a string describing the error code.
// This can be either a pointer to a string stored in buffer,
// or a pointer to some static immutable string.
// Returns one of the following values:
// 0 - success
// ERANGE - buffer is not large enough to store the error message
// other - failure
// Buffer should be at least of size 1.
FMT_FUNC int safe_strerror(int error_code, char*& buffer,
std::size_t buffer_size) FMT_NOEXCEPT {
FMT_ASSERT(buffer != nullptr && buffer_size != 0, "invalid buffer");
class dispatcher {
private:
int error_code_;
char*& buffer_;
std::size_t buffer_size_;
// A noop assignment operator to avoid bogus warnings.
void operator=(const dispatcher&) {}
// Handle the result of XSI-compliant version of strerror_r.
int handle(int result) {
// glibc versions before 2.13 return result in errno.
return result == -1 ? errno : result;
}
// Handle the result of GNU-specific version of strerror_r.
FMT_MAYBE_UNUSED
int handle(char* message) {
// If the buffer is full then the message is probably truncated.
if (message == buffer_ && strlen(buffer_) == buffer_size_ - 1)
return ERANGE;
buffer_ = message;
return 0;
}
// Handle the case when strerror_r is not available.
FMT_MAYBE_UNUSED
int handle(internal::null<>) {
return fallback(strerror_s(buffer_, buffer_size_, error_code_));
}
// Fallback to strerror_s when strerror_r is not available.
FMT_MAYBE_UNUSED
int fallback(int result) {
// If the buffer is full then the message is probably truncated.
return result == 0 && strlen(buffer_) == buffer_size_ - 1 ? ERANGE
: result;
}
#if !FMT_MSC_VER
// Fallback to strerror if strerror_r and strerror_s are not available.
int fallback(internal::null<>) {
errno = 0;
buffer_ = strerror(error_code_);
return errno;
}
#endif
public:
dispatcher(int err_code, char*& buf, std::size_t buf_size)
: error_code_(err_code), buffer_(buf), buffer_size_(buf_size) {}
int run() { return handle(strerror_r(error_code_, buffer_, buffer_size_)); }
};
return dispatcher(error_code, buffer, buffer_size).run();
}
FMT_FUNC void format_error_code(internal::buffer<char>& out, int error_code,
string_view message) FMT_NOEXCEPT {
// Report error code making sure that the output fits into
// inline_buffer_size to avoid dynamic memory allocation and potential
// bad_alloc.
out.resize(0);
static const char SEP[] = ": ";
static const char ERROR_STR[] = "error ";
// Subtract 2 to account for terminating null characters in SEP and ERROR_STR.
std::size_t error_code_size = sizeof(SEP) + sizeof(ERROR_STR) - 2;
auto abs_value = static_cast<uint32_or_64_or_128_t<int>>(error_code);
if (internal::is_negative(error_code)) {
abs_value = 0 - abs_value;
++error_code_size;
}
error_code_size += internal::to_unsigned(internal::count_digits(abs_value));
internal::writer w(out);
if (message.size() <= inline_buffer_size - error_code_size) {
w.write(message);
w.write(SEP);
}
w.write(ERROR_STR);
w.write(error_code);
assert(out.size() <= inline_buffer_size);
}
FMT_FUNC void report_error(format_func func, int error_code,
string_view message) FMT_NOEXCEPT {
memory_buffer full_message;
func(full_message, error_code, message);
// Don't use fwrite_fully because the latter may throw.
(void)std::fwrite(full_message.data(), full_message.size(), 1, stderr);
std::fputc('\n', stderr);
}
// A wrapper around fwrite that throws on error.
FMT_FUNC void fwrite_fully(const void* ptr, size_t size, size_t count,
FILE* stream) {
size_t written = std::fwrite(ptr, size, count, stream);
if (written < count) FMT_THROW(system_error(errno, "cannot write to file"));
}
} // namespace internal
#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
namespace internal {
template <typename Locale>
locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
static_assert(std::is_same<Locale, std::locale>::value, "");
}
template <typename Locale> Locale locale_ref::get() const {
static_assert(std::is_same<Locale, std::locale>::value, "");
return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
}
template <typename Char> FMT_FUNC std::string grouping_impl(locale_ref loc) {
return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>()).grouping();
}
template <typename Char> FMT_FUNC Char thousands_sep_impl(locale_ref loc) {
return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
.thousands_sep();
}
template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
.decimal_point();
}
} // namespace internal
#else
template <typename Char>
FMT_FUNC std::string internal::grouping_impl(locale_ref) {
return "\03";
}
template <typename Char>
FMT_FUNC Char internal::thousands_sep_impl(locale_ref) {
return FMT_STATIC_THOUSANDS_SEPARATOR;
}
template <typename Char>
FMT_FUNC Char internal::decimal_point_impl(locale_ref) {
return '.';
}
#endif
FMT_API FMT_FUNC format_error::~format_error() FMT_NOEXCEPT = default;
FMT_API FMT_FUNC system_error::~system_error() FMT_NOEXCEPT = default;
FMT_FUNC void system_error::init(int err_code, string_view format_str,
format_args args) {
error_code_ = err_code;
memory_buffer buffer;
format_system_error(buffer, err_code, vformat(format_str, args));
std::runtime_error& base = *this;
base = std::runtime_error(to_string(buffer));
}
namespace internal {
template <> FMT_FUNC int count_digits<4>(internal::fallback_uintptr n) {
// fallback_uintptr is always stored in little endian.
int i = static_cast<int>(sizeof(void*)) - 1;
while (i > 0 && n.value[i] == 0) --i;
auto char_digits = std::numeric_limits<unsigned char>::digits / 4;
return i >= 0 ? i * char_digits + count_digits<4, unsigned>(n.value[i]) : 1;
}
template <typename T>
const char basic_data<T>::digits[] =
"0001020304050607080910111213141516171819"
"2021222324252627282930313233343536373839"
"4041424344454647484950515253545556575859"
"6061626364656667686970717273747576777879"
"8081828384858687888990919293949596979899";
template <typename T>
const char basic_data<T>::hex_digits[] = "0123456789abcdef";
#define FMT_POWERS_OF_10(factor) \
factor * 10, (factor)*100, (factor)*1000, (factor)*10000, (factor)*100000, \
(factor)*1000000, (factor)*10000000, (factor)*100000000, \
(factor)*1000000000
template <typename T>
const uint64_t basic_data<T>::powers_of_10_64[] = {
1, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
10000000000000000000ULL};
template <typename T>
const uint32_t basic_data<T>::zero_or_powers_of_10_32[] = {0,
FMT_POWERS_OF_10(1)};
template <typename T>
const uint64_t basic_data<T>::zero_or_powers_of_10_64[] = {
0, FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1000000000ULL),
10000000000000000000ULL};
// Normalized 64-bit significands of pow(10, k), for k = -348, -340, ..., 340.
// These are generated by support/compute-powers.py.
template <typename T>
const uint64_t basic_data<T>::pow10_significands[] = {
0xfa8fd5a0081c0288, 0xbaaee17fa23ebf76, 0x8b16fb203055ac76,
0xcf42894a5dce35ea, 0x9a6bb0aa55653b2d, 0xe61acf033d1a45df,
0xab70fe17c79ac6ca, 0xff77b1fcbebcdc4f, 0xbe5691ef416bd60c,
0x8dd01fad907ffc3c, 0xd3515c2831559a83, 0x9d71ac8fada6c9b5,
0xea9c227723ee8bcb, 0xaecc49914078536d, 0x823c12795db6ce57,
0xc21094364dfb5637, 0x9096ea6f3848984f, 0xd77485cb25823ac7,
0xa086cfcd97bf97f4, 0xef340a98172aace5, 0xb23867fb2a35b28e,
0x84c8d4dfd2c63f3b, 0xc5dd44271ad3cdba, 0x936b9fcebb25c996,
0xdbac6c247d62a584, 0xa3ab66580d5fdaf6, 0xf3e2f893dec3f126,
0xb5b5ada8aaff80b8, 0x87625f056c7c4a8b, 0xc9bcff6034c13053,
0x964e858c91ba2655, 0xdff9772470297ebd, 0xa6dfbd9fb8e5b88f,
0xf8a95fcf88747d94, 0xb94470938fa89bcf, 0x8a08f0f8bf0f156b,
0xcdb02555653131b6, 0x993fe2c6d07b7fac, 0xe45c10c42a2b3b06,
0xaa242499697392d3, 0xfd87b5f28300ca0e, 0xbce5086492111aeb,
0x8cbccc096f5088cc, 0xd1b71758e219652c, 0x9c40000000000000,
0xe8d4a51000000000, 0xad78ebc5ac620000, 0x813f3978f8940984,
0xc097ce7bc90715b3, 0x8f7e32ce7bea5c70, 0xd5d238a4abe98068,
0x9f4f2726179a2245, 0xed63a231d4c4fb27, 0xb0de65388cc8ada8,
0x83c7088e1aab65db, 0xc45d1df942711d9a, 0x924d692ca61be758,
0xda01ee641a708dea, 0xa26da3999aef774a, 0xf209787bb47d6b85,
0xb454e4a179dd1877, 0x865b86925b9bc5c2, 0xc83553c5c8965d3d,
0x952ab45cfa97a0b3, 0xde469fbd99a05fe3, 0xa59bc234db398c25,
0xf6c69a72a3989f5c, 0xb7dcbf5354e9bece, 0x88fcf317f22241e2,
0xcc20ce9bd35c78a5, 0x98165af37b2153df, 0xe2a0b5dc971f303a,
0xa8d9d1535ce3b396, 0xfb9b7cd9a4a7443c, 0xbb764c4ca7a44410,
0x8bab8eefb6409c1a, 0xd01fef10a657842c, 0x9b10a4e5e9913129,
0xe7109bfba19c0c9d, 0xac2820d9623bf429, 0x80444b5e7aa7cf85,
0xbf21e44003acdd2d, 0x8e679c2f5e44ff8f, 0xd433179d9c8cb841,
0x9e19db92b4e31ba9, 0xeb96bf6ebadf77d9, 0xaf87023b9bf0ee6b,
};
// Binary exponents of pow(10, k), for k = -348, -340, ..., 340, corresponding
// to significands above.
template <typename T>
const int16_t basic_data<T>::pow10_exponents[] = {
-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954,
-927, -901, -874, -847, -821, -794, -768, -741, -715, -688, -661,
-635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369,
-343, -316, -289, -263, -236, -210, -183, -157, -130, -103, -77,
-50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216,
242, 269, 295, 322, 348, 375, 402, 428, 455, 481, 508,
534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800,
827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066};
template <typename T>
const char basic_data<T>::foreground_color[] = "\x1b[38;2;";
template <typename T>
const char basic_data<T>::background_color[] = "\x1b[48;2;";
template <typename T> const char basic_data<T>::reset_color[] = "\x1b[0m";
template <typename T> const wchar_t basic_data<T>::wreset_color[] = L"\x1b[0m";
template <typename T> const char basic_data<T>::signs[] = {0, '-', '+', ' '};
template <typename T> struct bits {
static FMT_CONSTEXPR_DECL const int value =
static_cast<int>(sizeof(T) * std::numeric_limits<unsigned char>::digits);
};
class fp;
template <int SHIFT = 0> fp normalize(fp value);
// Lower (upper) boundary is a value half way between a floating-point value
// and its predecessor (successor). Boundaries have the same exponent as the
// value so only significands are stored.
struct boundaries {
uint64_t lower;
uint64_t upper;
};
// A handmade floating-point number f * pow(2, e).
class fp {
private:
using significand_type = uint64_t;
public:
significand_type f;
int e;
// All sizes are in bits.
// Subtract 1 to account for an implicit most significant bit in the
// normalized form.
static FMT_CONSTEXPR_DECL const int double_significand_size =
std::numeric_limits<double>::digits - 1;
static FMT_CONSTEXPR_DECL const uint64_t implicit_bit =
1ULL << double_significand_size;
static FMT_CONSTEXPR_DECL const int significand_size =
bits<significand_type>::value;
fp() : f(0), e(0) {}
fp(uint64_t f_val, int e_val) : f(f_val), e(e_val) {}
// Constructs fp from an IEEE754 double. It is a template to prevent compile
// errors on platforms where double is not IEEE754.
template <typename Double> explicit fp(Double d) { assign(d); }
// Assigns d to this and return true iff predecessor is closer than successor.
template <typename Double, FMT_ENABLE_IF(sizeof(Double) == sizeof(uint64_t))>
bool assign(Double d) {
// Assume double is in the format [sign][exponent][significand].
using limits = std::numeric_limits<Double>;
const int exponent_size =
bits<Double>::value - double_significand_size - 1; // -1 for sign
const uint64_t significand_mask = implicit_bit - 1;
const uint64_t exponent_mask = (~0ULL >> 1) & ~significand_mask;
const int exponent_bias = (1 << exponent_size) - limits::max_exponent - 1;
auto u = bit_cast<uint64_t>(d);
f = u & significand_mask;
int biased_e =
static_cast<int>((u & exponent_mask) >> double_significand_size);
// Predecessor is closer if d is a normalized power of 2 (f == 0) other than
// the smallest normalized number (biased_e > 1).
bool is_predecessor_closer = f == 0 && biased_e > 1;
if (biased_e != 0)
f += implicit_bit;
else
biased_e = 1; // Subnormals use biased exponent 1 (min exponent).
e = biased_e - exponent_bias - double_significand_size;
return is_predecessor_closer;
}
template <typename Double, FMT_ENABLE_IF(sizeof(Double) != sizeof(uint64_t))>
bool assign(Double) {
*this = fp();
return false;
}
// Assigns d to this together with computing lower and upper boundaries,
// where a boundary is a value half way between the number and its predecessor
// (lower) or successor (upper). The upper boundary is normalized and lower
// has the same exponent but may be not normalized.
template <typename Double> boundaries assign_with_boundaries(Double d) {
bool is_lower_closer = assign(d);
fp lower =
is_lower_closer ? fp((f << 2) - 1, e - 2) : fp((f << 1) - 1, e - 1);
// 1 in normalize accounts for the exponent shift above.
fp upper = normalize<1>(fp((f << 1) + 1, e - 1));
lower.f <<= lower.e - upper.e;
return boundaries{lower.f, upper.f};
}
template <typename Double> boundaries assign_float_with_boundaries(Double d) {
assign(d);
constexpr int min_normal_e = std::numeric_limits<float>::min_exponent -
std::numeric_limits<double>::digits;
significand_type half_ulp = 1 << (std::numeric_limits<double>::digits -
std::numeric_limits<float>::digits - 1);
if (min_normal_e > e) half_ulp <<= min_normal_e - e;
fp upper = normalize<0>(fp(f + half_ulp, e));
fp lower = fp(
f - (half_ulp >> ((f == implicit_bit && e > min_normal_e) ? 1 : 0)), e);
lower.f <<= lower.e - upper.e;
return boundaries{lower.f, upper.f};
}
};
// Normalizes the value converted from double and multiplied by (1 << SHIFT).
template <int SHIFT> fp normalize(fp value) {
// Handle subnormals.
const auto shifted_implicit_bit = fp::implicit_bit << SHIFT;
while ((value.f & shifted_implicit_bit) == 0) {
value.f <<= 1;
--value.e;
}
// Subtract 1 to account for hidden bit.
const auto offset =
fp::significand_size - fp::double_significand_size - SHIFT - 1;
value.f <<= offset;
value.e -= offset;
return value;
}
inline bool operator==(fp x, fp y) { return x.f == y.f && x.e == y.e; }
// Computes lhs * rhs / pow(2, 64) rounded to nearest with half-up tie breaking.
inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
#if FMT_USE_INT128
auto product = static_cast<__uint128_t>(lhs) * rhs;
auto f = static_cast<uint64_t>(product >> 64);
return (static_cast<uint64_t>(product) & (1ULL << 63)) != 0 ? f + 1 : f;
#else
// Multiply 32-bit parts of significands.
uint64_t mask = (1ULL << 32) - 1;
uint64_t a = lhs >> 32, b = lhs & mask;
uint64_t c = rhs >> 32, d = rhs & mask;
uint64_t ac = a * c, bc = b * c, ad = a * d, bd = b * d;
// Compute mid 64-bit of result and round.
uint64_t mid = (bd >> 32) + (ad & mask) + (bc & mask) + (1U << 31);
return ac + (ad >> 32) + (bc >> 32) + (mid >> 32);
#endif
}
inline fp operator*(fp x, fp y) { return {multiply(x.f, y.f), x.e + y.e + 64}; }
// Returns a cached power of 10 `c_k = c_k.f * pow(2, c_k.e)` such that its
// (binary) exponent satisfies `min_exponent <= c_k.e <= min_exponent + 28`.
inline fp get_cached_power(int min_exponent, int& pow10_exponent) {
const int64_t one_over_log2_10 = 0x4d104d42; // round(pow(2, 32) / log2(10))
int index = static_cast<int>(
((min_exponent + fp::significand_size - 1) * one_over_log2_10 +
((int64_t(1) << 32) - 1)) // ceil
>> 32 // arithmetic shift
);
// Decimal exponent of the first (smallest) cached power of 10.
const int first_dec_exp = -348;
// Difference between 2 consecutive decimal exponents in cached powers of 10.
const int dec_exp_step = 8;
index = (index - first_dec_exp - 1) / dec_exp_step + 1;
pow10_exponent = first_dec_exp + index * dec_exp_step;
return {data::pow10_significands[index], data::pow10_exponents[index]};
}
// A simple accumulator to hold the sums of terms in bigint::square if uint128_t
// is not available.
struct accumulator {
uint64_t lower;
uint64_t upper;
accumulator() : lower(0), upper(0) {}
explicit operator uint32_t() const { return static_cast<uint32_t>(lower); }
void operator+=(uint64_t n) {
lower += n;
if (lower < n) ++upper;
}
void operator>>=(int shift) {
assert(shift == 32);
(void)shift;
lower = (upper << 32) | (lower >> 32);
upper >>= 32;
}
};
class bigint {
private:
// A bigint is stored as an array of bigits (big digits), with bigit at index
// 0 being the least significant one.
using bigit = uint32_t;
using double_bigit = uint64_t;
enum { bigits_capacity = 32 };
basic_memory_buffer<bigit, bigits_capacity> bigits_;
int exp_;
bigit operator[](int index) const { return bigits_[to_unsigned(index)]; }
bigit& operator[](int index) { return bigits_[to_unsigned(index)]; }
static FMT_CONSTEXPR_DECL const int bigit_bits = bits<bigit>::value;
friend struct formatter<bigint>;
void subtract_bigits(int index, bigit other, bigit& borrow) {
auto result = static_cast<double_bigit>((*this)[index]) - other - borrow;
(*this)[index] = static_cast<bigit>(result);
borrow = static_cast<bigit>(result >> (bigit_bits * 2 - 1));
}
void remove_leading_zeros() {
int num_bigits = static_cast<int>(bigits_.size()) - 1;
while (num_bigits > 0 && (*this)[num_bigits] == 0) --num_bigits;
bigits_.resize(to_unsigned(num_bigits + 1));
}
// Computes *this -= other assuming aligned bigints and *this >= other.
void subtract_aligned(const bigint& other) {
FMT_ASSERT(other.exp_ >= exp_, "unaligned bigints");
FMT_ASSERT(compare(*this, other) >= 0, "");
bigit borrow = 0;
int i = other.exp_ - exp_;
for (size_t j = 0, n = other.bigits_.size(); j != n; ++i, ++j) {
subtract_bigits(i, other.bigits_[j], borrow);
}
while (borrow > 0) subtract_bigits(i, 0, borrow);
remove_leading_zeros();
}
void multiply(uint32_t value) {
const double_bigit wide_value = value;
bigit carry = 0;
for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
double_bigit result = bigits_[i] * wide_value + carry;
bigits_[i] = static_cast<bigit>(result);
carry = static_cast<bigit>(result >> bigit_bits);
}
if (carry != 0) bigits_.push_back(carry);
}
void multiply(uint64_t value) {
const bigit mask = ~bigit(0);
const double_bigit lower = value & mask;
const double_bigit upper = value >> bigit_bits;
double_bigit carry = 0;
for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
double_bigit result = bigits_[i] * lower + (carry & mask);
carry =
bigits_[i] * upper + (result >> bigit_bits) + (carry >> bigit_bits);
bigits_[i] = static_cast<bigit>(result);
}
while (carry != 0) {
bigits_.push_back(carry & mask);
carry >>= bigit_bits;
}
}
public:
bigint() : exp_(0) {}
explicit bigint(uint64_t n) { assign(n); }
~bigint() { assert(bigits_.capacity() <= bigits_capacity); }
bigint(const bigint&) = delete;
void operator=(const bigint&) = delete;
void assign(const bigint& other) {
bigits_.resize(other.bigits_.size());
auto data = other.bigits_.data();
std::copy(data, data + other.bigits_.size(), bigits_.data());
exp_ = other.exp_;
}
void assign(uint64_t n) {
size_t num_bigits = 0;
do {
bigits_[num_bigits++] = n & ~bigit(0);
n >>= bigit_bits;
} while (n != 0);
bigits_.resize(num_bigits);
exp_ = 0;
}
int num_bigits() const { return static_cast<int>(bigits_.size()) + exp_; }
bigint& operator<<=(int shift) {
assert(shift >= 0);
exp_ += shift / bigit_bits;
shift %= bigit_bits;
if (shift == 0) return *this;
bigit carry = 0;
for (size_t i = 0, n = bigits_.size(); i < n; ++i) {
bigit c = bigits_[i] >> (bigit_bits - shift);
bigits_[i] = (bigits_[i] << shift) + carry;
carry = c;
}
if (carry != 0) bigits_.push_back(carry);
return *this;
}
template <typename Int> bigint& operator*=(Int value) {
FMT_ASSERT(value > 0, "");
multiply(uint32_or_64_or_128_t<Int>(value));
return *this;
}
friend int compare(const bigint& lhs, const bigint& rhs) {
int num_lhs_bigits = lhs.num_bigits(), num_rhs_bigits = rhs.num_bigits();
if (num_lhs_bigits != num_rhs_bigits)
return num_lhs_bigits > num_rhs_bigits ? 1 : -1;
int i = static_cast<int>(lhs.bigits_.size()) - 1;
int j = static_cast<int>(rhs.bigits_.size()) - 1;
int end = i - j;
if (end < 0) end = 0;
for (; i >= end; --i, --j) {
bigit lhs_bigit = lhs[i], rhs_bigit = rhs[j];
if (lhs_bigit != rhs_bigit) return lhs_bigit > rhs_bigit ? 1 : -1;
}
if (i != j) return i > j ? 1 : -1;
return 0;
}
// Returns compare(lhs1 + lhs2, rhs).
friend int add_compare(const bigint& lhs1, const bigint& lhs2,
const bigint& rhs) {
int max_lhs_bigits = (std::max)(lhs1.num_bigits(), lhs2.num_bigits());
int num_rhs_bigits = rhs.num_bigits();
if (max_lhs_bigits + 1 < num_rhs_bigits) return -1;
if (max_lhs_bigits > num_rhs_bigits) return 1;
auto get_bigit = [](const bigint& n, int i) -> bigit {
return i >= n.exp_ && i < n.num_bigits() ? n[i - n.exp_] : 0;
};
double_bigit borrow = 0;
int min_exp = (std::min)((std::min)(lhs1.exp_, lhs2.exp_), rhs.exp_);
for (int i = num_rhs_bigits - 1; i >= min_exp; --i) {
double_bigit sum =
static_cast<double_bigit>(get_bigit(lhs1, i)) + get_bigit(lhs2, i);
bigit rhs_bigit = get_bigit(rhs, i);
if (sum > rhs_bigit + borrow) return 1;
borrow = rhs_bigit + borrow - sum;
if (borrow > 1) return -1;
borrow <<= bigit_bits;
}
return borrow != 0 ? -1 : 0;
}
// Assigns pow(10, exp) to this bigint.
void assign_pow10(int exp) {
assert(exp >= 0);
if (exp == 0) return assign(1);
// Find the top bit.
int bitmask = 1;
while (exp >= bitmask) bitmask <<= 1;
bitmask >>= 1;
// pow(10, exp) = pow(5, exp) * pow(2, exp). First compute pow(5, exp) by
// repeated squaring and multiplication.
assign(5);
bitmask >>= 1;
while (bitmask != 0) {
square();
if ((exp & bitmask) != 0) *this *= 5;
bitmask >>= 1;
}
*this <<= exp; // Multiply by pow(2, exp) by shifting.
}
void square() {
basic_memory_buffer<bigit, bigits_capacity> n(std::move(bigits_));
int num_bigits = static_cast<int>(bigits_.size());
int num_result_bigits = 2 * num_bigits;
bigits_.resize(to_unsigned(num_result_bigits));
using accumulator_t = conditional_t<FMT_USE_INT128, uint128_t, accumulator>;
auto sum = accumulator_t();
for (int bigit_index = 0; bigit_index < num_bigits; ++bigit_index) {
// Compute bigit at position bigit_index of the result by adding
// cross-product terms n[i] * n[j] such that i + j == bigit_index.
for (int i = 0, j = bigit_index; j >= 0; ++i, --j) {
// Most terms are multiplied twice which can be optimized in the future.
sum += static_cast<double_bigit>(n[i]) * n[j];
}
(*this)[bigit_index] = static_cast<bigit>(sum);
sum >>= bits<bigit>::value; // Compute the carry.
}
// Do the same for the top half.
for (int bigit_index = num_bigits; bigit_index < num_result_bigits;
++bigit_index) {
for (int j = num_bigits - 1, i = bigit_index - j; i < num_bigits;)
sum += static_cast<double_bigit>(n[i++]) * n[j--];
(*this)[bigit_index] = static_cast<bigit>(sum);
sum >>= bits<bigit>::value;
}
--num_result_bigits;
remove_leading_zeros();
exp_ *= 2;
}
// Divides this bignum by divisor, assigning the remainder to this and
// returning the quotient.
int divmod_assign(const bigint& divisor) {
FMT_ASSERT(this != &divisor, "");
if (compare(*this, divisor) < 0) return 0;
int num_bigits = static_cast<int>(bigits_.size());
FMT_ASSERT(divisor.bigits_[divisor.bigits_.size() - 1u] != 0, "");
int exp_difference = exp_ - divisor.exp_;
if (exp_difference > 0) {
// Align bigints by adding trailing zeros to simplify subtraction.
bigits_.resize(to_unsigned(num_bigits + exp_difference));
for (int i = num_bigits - 1, j = i + exp_difference; i >= 0; --i, --j)
bigits_[j] = bigits_[i];
std::uninitialized_fill_n(bigits_.data(), exp_difference, 0);
exp_ -= exp_difference;
}
int quotient = 0;
do {
subtract_aligned(divisor);
++quotient;
} while (compare(*this, divisor) >= 0);
return quotient;
}
};
enum class round_direction { unknown, up, down };
// Given the divisor (normally a power of 10), the remainder = v % divisor for
// some number v and the error, returns whether v should be rounded up, down, or
// whether the rounding direction can't be determined due to error.
// error should be less than divisor / 2.
inline round_direction get_round_direction(uint64_t divisor, uint64_t remainder,
uint64_t error) {
FMT_ASSERT(remainder < divisor, ""); // divisor - remainder won't overflow.
FMT_ASSERT(error < divisor, ""); // divisor - error won't overflow.
FMT_ASSERT(error < divisor - error, ""); // error * 2 won't overflow.
// Round down if (remainder + error) * 2 <= divisor.
if (remainder <= divisor - remainder && error * 2 <= divisor - remainder * 2)
return round_direction::down;
// Round up if (remainder - error) * 2 >= divisor.
if (remainder >= error &&
remainder - error >= divisor - (remainder - error)) {
return round_direction::up;
}
return round_direction::unknown;
}
namespace digits {
enum result {
more, // Generate more digits.
done, // Done generating digits.
error // Digit generation cancelled due to an error.
};
}
// A version of count_digits optimized for grisu_gen_digits.
inline int grisu_count_digits(uint32_t n) {
if (n < 10) return 1;
if (n < 100) return 2;
if (n < 1000) return 3;
if (n < 10000) return 4;
if (n < 100000) return 5;
if (n < 1000000) return 6;
if (n < 10000000) return 7;
if (n < 100000000) return 8;
if (n < 1000000000) return 9;
return 10;
}
// Generates output using the Grisu digit-gen algorithm.
// error: the size of the region (lower, upper) outside of which numbers
// definitely do not round to value (Delta in Grisu3).
template <typename Handler>
FMT_ALWAYS_INLINE digits::result grisu_gen_digits(fp value, uint64_t error,
int& exp, Handler& handler) {
const fp one(1ULL << -value.e, value.e);
// The integral part of scaled value (p1 in Grisu) = value / one. It cannot be
// zero because it contains a product of two 64-bit numbers with MSB set (due
// to normalization) - 1, shifted right by at most 60 bits.
auto integral = static_cast<uint32_t>(value.f >> -one.e);
FMT_ASSERT(integral != 0, "");
FMT_ASSERT(integral == value.f >> -one.e, "");
// The fractional part of scaled value (p2 in Grisu) c = value % one.
uint64_t fractional = value.f & (one.f - 1);
exp = grisu_count_digits(integral); // kappa in Grisu.
// Divide by 10 to prevent overflow.
auto result = handler.on_start(data::powers_of_10_64[exp - 1] << -one.e,
value.f / 10, error * 10, exp);
if (result != digits::more) return result;
// Generate digits for the integral part. This can produce up to 10 digits.
do {
uint32_t digit = 0;
auto divmod_integral = [&](uint32_t divisor) {
digit = integral / divisor;
integral %= divisor;
};
// This optimization by Milo Yip reduces the number of integer divisions by
// one per iteration.
switch (exp) {
case 10:
divmod_integral(1000000000);
break;
case 9:
divmod_integral(100000000);
break;
case 8:
divmod_integral(10000000);
break;
case 7:
divmod_integral(1000000);
break;
case 6:
divmod_integral(100000);
break;
case 5:
divmod_integral(10000);
break;
case 4:
divmod_integral(1000);
break;
case 3:
divmod_integral(100);
break;
case 2:
divmod_integral(10);
break;
case 1:
digit = integral;
integral = 0;
break;
default:
FMT_ASSERT(false, "invalid number of digits");
}
--exp;
uint64_t remainder =
(static_cast<uint64_t>(integral) << -one.e) + fractional;
result = handler.on_digit(static_cast<char>('0' + digit),
data::powers_of_10_64[exp] << -one.e, remainder,
error, exp, true);
if (result != digits::more) return result;
} while (exp > 0);
// Generate digits for the fractional part.
for (;;) {
fractional *= 10;
error *= 10;
char digit =
static_cast<char>('0' + static_cast<char>(fractional >> -one.e));
fractional &= one.f - 1;
--exp;
result = handler.on_digit(digit, one.f, fractional, error, exp, false);
if (result != digits::more) return result;
}
}
// The fixed precision digit handler.
struct fixed_handler {
char* buf;
int size;
int precision;
int exp10;
bool fixed;
digits::result on_start(uint64_t divisor, uint64_t remainder, uint64_t error,
int& exp) {
// Non-fixed formats require at least one digit and no precision adjustment.
if (!fixed) return digits::more;
// Adjust fixed precision by exponent because it is relative to decimal
// point.
precision += exp + exp10;
// Check if precision is satisfied just by leading zeros, e.g.
// format("{:.2f}", 0.001) gives "0.00" without generating any digits.
if (precision > 0) return digits::more;
if (precision < 0) return digits::done;
auto dir = get_round_direction(divisor, remainder, error);
if (dir == round_direction::unknown) return digits::error;
buf[size++] = dir == round_direction::up ? '1' : '0';
return digits::done;
}
digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
uint64_t error, int, bool integral) {
FMT_ASSERT(remainder < divisor, "");
buf[size++] = digit;
if (size < precision) return digits::more;
if (!integral) {
// Check if error * 2 < divisor with overflow prevention.
// The check is not needed for the integral part because error = 1
// and divisor > (1 << 32) there.
if (error >= divisor || error >= divisor - error) return digits::error;
} else {
FMT_ASSERT(error == 1 && divisor > 2, "");
}
auto dir = get_round_direction(divisor, remainder, error);
if (dir != round_direction::up)
return dir == round_direction::down ? digits::done : digits::error;
++buf[size - 1];
for (int i = size - 1; i > 0 && buf[i] > '9'; --i) {
buf[i] = '0';
++buf[i - 1];
}
if (buf[0] > '9') {
buf[0] = '1';
buf[size++] = '0';
}
return digits::done;
}
};
// The shortest representation digit handler.
struct grisu_shortest_handler {
char* buf;
int size;
// Distance between scaled value and upper bound (wp_W in Grisu3).
uint64_t diff;
digits::result on_start(uint64_t, uint64_t, uint64_t, int&) {
return digits::more;
}
// Decrement the generated number approaching value from above.
void round(uint64_t d, uint64_t divisor, uint64_t& remainder,
uint64_t error) {
while (
remainder < d && error - remainder >= divisor &&
(remainder + divisor < d || d - remainder >= remainder + divisor - d)) {
--buf[size - 1];
remainder += divisor;
}
}
// Implements Grisu's round_weed.
digits::result on_digit(char digit, uint64_t divisor, uint64_t remainder,
uint64_t error, int exp, bool integral) {
buf[size++] = digit;
if (remainder >= error) return digits::more;
uint64_t unit = integral ? 1 : data::powers_of_10_64[-exp];
uint64_t up = (diff - 1) * unit; // wp_Wup
round(up, divisor, remainder, error);
uint64_t down = (diff + 1) * unit; // wp_Wdown
if (remainder < down && error - remainder >= divisor &&
(remainder + divisor < down ||
down - remainder > remainder + divisor - down)) {
return digits::error;
}
return 2 * unit <= remainder && remainder <= error - 4 * unit
? digits::done
: digits::error;
}
};
// Formats value using a variation of the Fixed-Precision Positive
// Floating-Point Printout ((FPP)^2) algorithm by Steele & White:
// https://fmt.dev/p372-steele.pdf.
template <typename Double>
void fallback_format(Double d, buffer<char>& buf, int& exp10) {
bigint numerator; // 2 * R in (FPP)^2.
bigint denominator; // 2 * S in (FPP)^2.
// lower and upper are differences between value and corresponding boundaries.
bigint lower; // (M^- in (FPP)^2).
bigint upper_store; // upper's value if different from lower.
bigint* upper = nullptr; // (M^+ in (FPP)^2).
fp value;
// Shift numerator and denominator by an extra bit or two (if lower boundary
// is closer) to make lower and upper integers. This eliminates multiplication
// by 2 during later computations.
// TODO: handle float
int shift = value.assign(d) ? 2 : 1;
uint64_t significand = value.f << shift;
if (value.e >= 0) {
numerator.assign(significand);
numerator <<= value.e;
lower.assign(1);
lower <<= value.e;
if (shift != 1) {
upper_store.assign(1);
upper_store <<= value.e + 1;
upper = &upper_store;
}
denominator.assign_pow10(exp10);
denominator <<= 1;
} else if (exp10 < 0) {
numerator.assign_pow10(-exp10);
lower.assign(numerator);
if (shift != 1) {
upper_store.assign(numerator);
upper_store <<= 1;
upper = &upper_store;
}
numerator *= significand;
denominator.assign(1);
denominator <<= shift - value.e;
} else {
numerator.assign(significand);
denominator.assign_pow10(exp10);
denominator <<= shift - value.e;
lower.assign(1);
if (shift != 1) {
upper_store.assign(1ULL << 1);
upper = &upper_store;
}
}
if (!upper) upper = &lower;
// Invariant: value == (numerator / denominator) * pow(10, exp10).
bool even = (value.f & 1) == 0;
int num_digits = 0;
char* data = buf.data();
for (;;) {
int digit = numerator.divmod_assign(denominator);
bool low = compare(numerator, lower) - even < 0; // numerator <[=] lower.
// numerator + upper >[=] pow10:
bool high = add_compare(numerator, *upper, denominator) + even > 0;
data[num_digits++] = static_cast<char>('0' + digit);
if (low || high) {
if (!low) {
++data[num_digits - 1];
} else if (high) {
int result = add_compare(numerator, numerator, denominator);
// Round half to even.
if (result > 0 || (result == 0 && (digit % 2) != 0))
++data[num_digits - 1];
}
buf.resize(to_unsigned(num_digits));
exp10 -= num_digits - 1;
return;
}
numerator *= 10;
lower *= 10;
if (upper != &lower) *upper *= 10;
}
}
// Formats value using the Grisu algorithm
// (https://www.cs.tufts.edu/~nr/cs257/archive/florian-loitsch/printf.pdf)
// if T is a IEEE754 binary32 or binary64 and snprintf otherwise.
template <typename T>
int format_float(T value, int precision, float_specs specs, buffer<char>& buf) {
static_assert(!std::is_same<T, float>::value, "");
FMT_ASSERT(value >= 0, "value is negative");
const bool fixed = specs.format == float_format::fixed;
if (value <= 0) { // <= instead of == to silence a warning.
if (precision <= 0 || !fixed) {
buf.push_back('0');
return 0;
}
buf.resize(to_unsigned(precision));
std::uninitialized_fill_n(buf.data(), precision, '0');
return -precision;
}
if (!specs.use_grisu) return snprintf_float(value, precision, specs, buf);
int exp = 0;
const int min_exp = -60; // alpha in Grisu.
int cached_exp10 = 0; // K in Grisu.
if (precision < 0) {
fp fp_value;
auto boundaries = specs.binary32
? fp_value.assign_float_with_boundaries(value)
: fp_value.assign_with_boundaries(value);
fp_value = normalize(fp_value);
// Find a cached power of 10 such that multiplying value by it will bring
// the exponent in the range [min_exp, -32].
const fp cached_pow = get_cached_power(
min_exp - (fp_value.e + fp::significand_size), cached_exp10);
// Multiply value and boundaries by the cached power of 10.
fp_value = fp_value * cached_pow;
boundaries.lower = multiply(boundaries.lower, cached_pow.f);
boundaries.upper = multiply(boundaries.upper, cached_pow.f);
assert(min_exp <= fp_value.e && fp_value.e <= -32);
--boundaries.lower; // \tilde{M}^- - 1 ulp -> M^-_{\downarrow}.
++boundaries.upper; // \tilde{M}^+ + 1 ulp -> M^+_{\uparrow}.
// Numbers outside of (lower, upper) definitely do not round to value.
grisu_shortest_handler handler{buf.data(), 0,
boundaries.upper - fp_value.f};
auto result =
grisu_gen_digits(fp(boundaries.upper, fp_value.e),
boundaries.upper - boundaries.lower, exp, handler);
if (result == digits::error) {
exp += handler.size - cached_exp10 - 1;
fallback_format(value, buf, exp);
return exp;
}
buf.resize(to_unsigned(handler.size));
} else {
if (precision > 17) return snprintf_float(value, precision, specs, buf);
fp normalized = normalize(fp(value));
const auto cached_pow = get_cached_power(
min_exp - (normalized.e + fp::significand_size), cached_exp10);
normalized = normalized * cached_pow;
fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
if (grisu_gen_digits(normalized, 1, exp, handler) == digits::error)
return snprintf_float(value, precision, specs, buf);
int num_digits = handler.size;
if (!fixed) {
// Remove trailing zeros.
while (num_digits > 0 && buf[num_digits - 1] == '0') {
--num_digits;
++exp;
}
}
buf.resize(to_unsigned(num_digits));
}
return exp - cached_exp10;
}
template <typename T>
int snprintf_float(T value, int precision, float_specs specs,
buffer<char>& buf) {
// Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
FMT_ASSERT(buf.capacity() > buf.size(), "empty buffer");
static_assert(!std::is_same<T, float>::value, "");
// Subtract 1 to account for the difference in precision since we use %e for
// both general and exponent format.
if (specs.format == float_format::general ||
specs.format == float_format::exp)
precision = (precision >= 0 ? precision : 6) - 1;
// Build the format string.
enum { max_format_size = 7 }; // Ths longest format is "%#.*Le".
char format[max_format_size];
char* format_ptr = format;
*format_ptr++ = '%';
if (specs.showpoint && specs.format == float_format::hex) *format_ptr++ = '#';
if (precision >= 0) {
*format_ptr++ = '.';
*format_ptr++ = '*';
}
if (std::is_same<T, long double>()) *format_ptr++ = 'L';
*format_ptr++ = specs.format != float_format::hex
? (specs.format == float_format::fixed ? 'f' : 'e')
: (specs.upper ? 'A' : 'a');
*format_ptr = '\0';
// Format using snprintf.
auto offset = buf.size();
for (;;) {
auto begin = buf.data() + offset;
auto capacity = buf.capacity() - offset;
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
if (precision > 100000)
throw std::runtime_error(
"fuzz mode - avoid large allocation inside snprintf");
#endif
// Suppress the warning about a nonliteral format string.
// Cannot use auto becase of a bug in MinGW (#1532).
int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
int result = precision >= 0
? snprintf_ptr(begin, capacity, format, precision, value)
: snprintf_ptr(begin, capacity, format, value);
if (result < 0) {
buf.reserve(buf.capacity() + 1); // The buffer will grow exponentially.
continue;
}
auto size = to_unsigned(result);
// Size equal to capacity means that the last character was truncated.
if (size >= capacity) {
buf.reserve(size + offset + 1); // Add 1 for the terminating '\0'.
continue;
}
auto is_digit = [](char c) { return c >= '0' && c <= '9'; };
if (specs.format == float_format::fixed) {
if (precision == 0) {
buf.resize(size);
return 0;
}
// Find and remove the decimal point.
auto end = begin + size, p = end;
do {
--p;
} while (is_digit(*p));
int fraction_size = static_cast<int>(end - p - 1);
std::memmove(p, p + 1, to_unsigned(fraction_size));
buf.resize(size - 1);
return -fraction_size;
}
if (specs.format == float_format::hex) {
buf.resize(size + offset);
return 0;
}
// Find and parse the exponent.
auto end = begin + size, exp_pos = end;
do {
--exp_pos;
} while (*exp_pos != 'e');
char sign = exp_pos[1];
assert(sign == '+' || sign == '-');
int exp = 0;
auto p = exp_pos + 2; // Skip 'e' and sign.
do {
assert(is_digit(*p));
exp = exp * 10 + (*p++ - '0');
} while (p != end);
if (sign == '-') exp = -exp;
int fraction_size = 0;
if (exp_pos != begin + 1) {
// Remove trailing zeros.
auto fraction_end = exp_pos - 1;
while (*fraction_end == '0') --fraction_end;
// Move the fractional part left to get rid of the decimal point.
fraction_size = static_cast<int>(fraction_end - begin - 1);
std::memmove(begin + 1, begin + 2, to_unsigned(fraction_size));
}
buf.resize(to_unsigned(fraction_size) + offset + 1);
return exp - fraction_size;
}
}
// A public domain branchless UTF-8 decoder by Christopher Wellons:
// https://github.com/skeeto/branchless-utf8
/* Decode the next character, c, from buf, reporting errors in e.
*
* Since this is a branchless decoder, four bytes will be read from the
* buffer regardless of the actual length of the next character. This
* means the buffer _must_ have at least three bytes of zero padding
* following the end of the data stream.
*
* Errors are reported in e, which will be non-zero if the parsed
* character was somehow invalid: invalid byte sequence, non-canonical
* encoding, or a surrogate half.
*
* The function returns a pointer to the next character. When an error
* occurs, this pointer will be a guess that depends on the particular
* error, but it will always advance at least one byte.
*/
FMT_FUNC const char* utf8_decode(const char* buf, uint32_t* c, int* e) {
static const char lengths[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 2, 2, 2, 2, 3, 3, 4, 0};
static const int masks[] = {0x00, 0x7f, 0x1f, 0x0f, 0x07};
static const uint32_t mins[] = {4194304, 0, 128, 2048, 65536};
static const int shiftc[] = {0, 18, 12, 6, 0};
static const int shifte[] = {0, 6, 4, 2, 0};
auto s = reinterpret_cast<const unsigned char*>(buf);
int len = lengths[s[0] >> 3];
// Compute the pointer to the next character early so that the next
// iteration can start working on the next character. Neither Clang
// nor GCC figure out this reordering on their own.
const char* next = buf + len + !len;
// Assume a four-byte character and load four bytes. Unused bits are
// shifted out.
*c = uint32_t(s[0] & masks[len]) << 18;
*c |= uint32_t(s[1] & 0x3f) << 12;
*c |= uint32_t(s[2] & 0x3f) << 6;
*c |= uint32_t(s[3] & 0x3f) << 0;
*c >>= shiftc[len];
// Accumulate the various error conditions.
*e = (*c < mins[len]) << 6; // non-canonical encoding
*e |= ((*c >> 11) == 0x1b) << 7; // surrogate half?
*e |= (*c > 0x10FFFF) << 8; // out of range?
*e |= (s[1] & 0xc0) >> 2;
*e |= (s[2] & 0xc0) >> 4;
*e |= (s[3]) >> 6;
*e ^= 0x2a; // top two bits of each tail byte correct?
*e >>= shifte[len];
return next;
}
} // namespace internal
template <> struct formatter<internal::bigint> {
format_parse_context::iterator parse(format_parse_context& ctx) {
return ctx.begin();
}
format_context::iterator format(const internal::bigint& n,
format_context& ctx) {
auto out = ctx.out();
bool first = true;
for (auto i = n.bigits_.size(); i > 0; --i) {
auto value = n.bigits_[i - 1u];
if (first) {
out = format_to(out, "{:x}", value);
first = false;
continue;
}
out = format_to(out, "{:08x}", value);
}
if (n.exp_ > 0)
out = format_to(out, "p{}", n.exp_ * internal::bigint::bigit_bits);
return out;
}
};
FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
auto transcode = [this](const char* p) {
auto cp = uint32_t();
auto error = 0;
p = utf8_decode(p, &cp, &error);
if (error != 0) FMT_THROW(std::runtime_error("invalid utf8"));
if (cp <= 0xFFFF) {
buffer_.push_back(static_cast<wchar_t>(cp));
} else {
cp -= 0x10000;
buffer_.push_back(static_cast<wchar_t>(0xD800 + (cp >> 10)));
buffer_.push_back(static_cast<wchar_t>(0xDC00 + (cp & 0x3FF)));
}
return p;
};
auto p = s.data();
const size_t block_size = 4; // utf8_decode always reads blocks of 4 chars.
if (s.size() >= block_size) {
for (auto end = p + s.size() - block_size + 1; p < end;) p = transcode(p);
}
if (auto num_chars_left = s.data() + s.size() - p) {
char buf[2 * block_size - 1] = {};
memcpy(buf, p, to_unsigned(num_chars_left));
p = buf;
do {
p = transcode(p);
} while (p - buf < num_chars_left);
}
buffer_.push_back(0);
}
FMT_FUNC void format_system_error(internal::buffer<char>& out, int error_code,
string_view message) FMT_NOEXCEPT {
FMT_TRY {
memory_buffer buf;
buf.resize(inline_buffer_size);
for (;;) {
char* system_message = &buf[0];
int result =
internal::safe_strerror(error_code, system_message, buf.size());
if (result == 0) {
internal::writer w(out);
w.write(message);
w.write(": ");
w.write(system_message);
return;
}
if (result != ERANGE)
break; // Can't get error message, report error code instead.
buf.resize(buf.size() * 2);
}
}
FMT_CATCH(...) {}
format_error_code(out, error_code, message);
}
FMT_FUNC void internal::error_handler::on_error(const char* message) {
FMT_THROW(format_error(message));
}
FMT_FUNC void report_system_error(int error_code,
fmt::string_view message) FMT_NOEXCEPT {
report_error(format_system_error, error_code, message);
}
FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
memory_buffer buffer;
internal::vformat_to(buffer, format_str,
basic_format_args<buffer_context<char>>(args));
#ifdef _WIN32
auto fd = _fileno(f);
if (_isatty(fd)) {
internal::utf8_to_utf16 u16(string_view(buffer.data(), buffer.size()));
auto written = DWORD();
if (!WriteConsoleW(reinterpret_cast<HANDLE>(_get_osfhandle(fd)),
u16.c_str(), static_cast<DWORD>(u16.size()), &written,
nullptr)) {
FMT_THROW(format_error("failed to write to console"));
}
return;
}
#endif
internal::fwrite_fully(buffer.data(), 1, buffer.size(), f);
}
#ifdef _WIN32
// Print assuming legacy (non-Unicode) encoding.
FMT_FUNC void internal::vprint_mojibake(std::FILE* f, string_view format_str,
format_args args) {
memory_buffer buffer;
internal::vformat_to(buffer, format_str,
basic_format_args<buffer_context<char>>(args));
fwrite_fully(buffer.data(), 1, buffer.size(), f);
}
#endif
FMT_FUNC void vprint(string_view format_str, format_args args) {
vprint(stdout, format_str, args);
}
FMT_END_NAMESPACE
#ifdef _MSC_VER
# pragma warning(pop)
#endif
#endif // FMT_FORMAT_INL_H_
================================================
FILE: examples/lesson04/fig04_12/fmt/format.h
================================================
/*
Formatting library for C++
Copyright (c) 2012 - present, Victor Zverovich
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- Optional exception to the license ---
As an exception, if, as a result of your compiling your source code, portions
of this Software are embedded into a machine-executable object form of such
source code, you may redistribute such embedded portions in such object form
without including the above copyright and permission notices.
*/
#ifndef FMT_FORMAT_H_
#define FMT_FORMAT_H_
#include <algorithm>
#include <cerrno>
#include <cmath>
#include <cstdint>
#include <limits>
#include <memory>
#include <stdexcept>
#include "core.h"
#ifdef FMT_DEPRECATED_INCLUDE_OS
# include "os.h"
#endif
#ifdef __INTEL_COMPILER
# define FMT_ICC_VERSION __INTEL_COMPILER
#elif defined(__ICL)
# define FMT_ICC_VERSION __ICL
#else
# define FMT_ICC_VERSION 0
#endif
#ifdef __NVCC__
# define FMT_CUDA_VERSION (__CUDACC_VER_MAJOR__ * 100 + __CUDACC_VER_MINOR__)
#else
# define FMT_CUDA_VERSION 0
#endif
#ifdef __has_builtin
# define FMT_HAS_BUILTIN(x) __has_builtin(x)
#else
# define FMT_HAS_BUILTIN(x) 0
#endif
#if FMT_GCC_VERSION || FMT_CLANG_VERSION
# define FMT_NOINLINE __attribute__((noinline))
#else
# define FMT_NOINLINE
#endif
#if __cplusplus == 201103L || __cplusplus == 201402L
# if defined(__clang__)
# define FMT_FALLTHROUGH [[clang::fallthrough]]
# elif FMT_GCC_VERSION >= 700 && !defined(__PGI)
# define FMT_FALLTHROUGH [[gnu::fallthrough]]
# else
# define FMT_FALLTHROUGH
# endif
#elif FMT_HAS_CPP17_ATTRIBUTE(fallthrough) || \
(defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
# define FMT_FALLTHROUGH [[fallthrough]]
#else
# define FMT_FALLTHROUGH
#endif
#ifndef FMT_THROW
# if FMT_EXCEPTIONS
# if FMT_MSC_VER || FMT_NVCC
FMT_BEGIN_NAMESPACE
namespace internal {
template <typename Exception> inline void do_throw(const Exception& x) {
// Silence unreachable code warnings in MSVC and NVCC because these
// are nearly impossible to fix in a generic code.
volatile bool b = true;
if (b) throw x;
}
} // namespace internal
FMT_END_NAMESPACE
# define FMT_THROW(x) internal::do_throw(x)
# else
# define FMT_THROW(x) throw x
# endif
# else
# define FMT_THROW(x) \
do { \
static_cast<void>(sizeof(x)); \
FMT_ASSERT(false, ""); \
} while (false)
# endif
#endif
#if FMT_EXCEPTIONS
# define FMT_TRY try
# define FMT_CATCH(x) catch (x)
#else
# define FMT_TRY if (true)
# define FMT_CATCH(x) if (false)
#endif
#ifndef FMT_USE_USER_DEFINED_LITERALS
// For Intel and NVIDIA compilers both they and the system gcc/msc support UDLs.
# if (FMT_HAS_FEATURE(cxx_user_literals) || FMT_GCC_VERSION >= 407 || \
FMT_MSC_VER >= 1900) && \
(!(FMT_ICC_VERSION || FMT_CUDA_VERSION) || FMT_ICC_VERSION >= 1500 || \
FMT_CUDA_VERSION >= 700)
# define FMT_USE_USER_DEFINED_LITERALS 1
# else
# define FMT_USE_USER_DEFINED_LITERALS 0
# endif
#endif
#ifndef FMT_USE_UDL_TEMPLATE
// EDG front end based compilers (icc, nvcc) and GCC < 6.4 do not propertly
// support UDL templates and GCC >= 9 warns about them.
# if FMT_USE_USER_DEFINED_LITERALS && FMT_ICC_VERSION == 0 && \
FMT_CUDA_VERSION == 0 && \
((FMT_GCC_VERSION >= 604 && FMT_GCC_VERSION <= 900 && \
__cplusplus >= 201402L) || \
FMT_CLANG_VERSION >= 304)
# define FMT_USE_UDL_TEMPLATE 1
# else
# define FMT_USE_UDL_TEMPLATE 0
# endif
#endif
#ifndef FMT_USE_FLOAT
# define FMT_USE_FLOAT 1
#endif
#ifndef FMT_USE_DOUBLE
# define FMT_USE_DOUBLE 1
#endif
#ifndef FMT_USE_LONG_DOUBLE
# define FMT_USE_LONG_DOUBLE 1
#endif
// __builtin_clz is broken in clang with Microsoft CodeGen:
// https://github.com/fmtlib/fmt/issues/519
#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clz)) && !FMT_MSC_VER
# define FMT_BUILTIN_CLZ(n) __builtin_clz(n)
#endif
#if (FMT_GCC_VERSION || FMT_HAS_BUILTIN(__builtin_clzll)) && !FMT_MSC_VER
# define FMT_BUILTIN_CLZLL(n) __builtin_clzll(n)
#endif
// Some compilers masquerade as both MSVC and GCC-likes or otherwise support
// __builtin_clz and __builtin_clzll, so only define FMT_BUILTIN_CLZ using the
// MSVC intrinsics if the clz and clzll builtins are not available.
#if FMT_MSC_VER && !defined(FMT_BUILTIN_CLZLL) && !defined(_MANAGED)
# include <intrin.h> // _BitScanReverse, _BitScanReverse64
FMT_BEGIN_NAMESPACE
namespace internal {
// Avoid Clang with Microsoft CodeGen's -Wunknown-pragmas warning.
# ifndef __clang__
# pragma intrinsic(_BitScanReverse)
# endif
inline uint32_t clz(uint32_t x) {
unsigned long r = 0;
_BitScanReverse(&r, x);
FMT_ASSERT(x != 0, "");
// Static analysis complains about using uninitialized data
// "r", but the only way that can happen is if "x" is 0,
// which the callers guarantee to not happen.
# pragma warning(suppress : 6102)
return 31 - r;
}
# define FMT_BUILTIN_CLZ(n) internal::clz(n)
# if defined(_WIN64) && !defined(__clang__)
# pragma intrinsic(_BitScanReverse64)
# endif
inline uint32_t clzll(uint64_t x) {
unsigned long r = 0;
# ifdef _WIN64
_BitScanReverse64(&r, x);
# else
// Scan the high 32 bits.
if (_BitScanReverse(&r, static_cast<uint32_t>(x >> 32))) return 63 - (r + 32);
// Scan the low 32 bits.
_BitScanReverse(&r, static_cast<uint32_t>(x));
# endif
FMT_ASSERT(x != 0, "");
// Static analysis complains about using uninitialized data
// "r", but the only way that can happen is if "x" is 0,
// which the callers guarantee to not happen.
# pragma warning(suppress : 6102)
return 63 - r;
}
# define FMT_BUILTIN_CLZLL(n) internal::clzll(n)
} // namespace internal
FMT_END_NAMESPACE
#endif
// Enable the deprecated numeric alignment.
#ifndef FMT_NUMERIC_ALIGN
# define FMT_NUMERIC_ALIGN 1
#endif
// Enable the deprecated percent specifier.
#ifndef FMT_DEPRECATED_PERCENT
# define FMT_DEPRECATED_PERCENT 0
#endif
FMT_BEGIN_NAMESPACE
namespace internal {
// An equivalent of `*reinterpret_cast<Dest*>(&source)` that doesn't have
// undefined behavior (e.g. due to type aliasing).
// Example: uint64_t d = bit_cast<uint64_t>(2.718);
template <typename Dest, typename Source>
inline Dest bit_cast(const Source& source) {
static_assert(sizeof(Dest) == sizeof(Source), "size mismatch");
Dest dest;
std::memcpy(&dest, &source, sizeof(dest));
return dest;
}
inline bool is_big_endian() {
const auto u = 1u;
struct bytes {
char data[sizeof(u)];
};
return bit_cast<bytes>(u).data[0] == 0;
}
// A fallback implementation of uintptr_t for systems that lack it.
struct fallback_uintptr {
unsigned char value[sizeof(void*)];
fallback_uintptr() = default;
explicit fallback_uintptr(const void* p) {
*this = bit_cast<fallback_uintptr>(p);
if (is_big_endian()) {
for (size_t i = 0, j = sizeof(void*) - 1; i < j; ++i, --j)
std::swap(value[i], value[j]);
}
}
};
#ifdef UINTPTR_MAX
using uintptr_t = ::uintptr_t;
inline uintptr_t to_uintptr(const void* p) { return bit_cast<uintptr_t>(p); }
#else
using uintptr_t = fallback_uintptr;
inline fallback_uintptr to_uintptr(const void* p) {
return fallback_uintptr(p);
}
#endif
// Returns the largest possible value for type T. Same as
// std::numeric_limits<T>::max() but shorter and not affected by the max macro.
template <typename T> constexpr T max_value() {
return (std::numeric_limits<T>::max)();
}
template <typename T> constexpr int num_bits() {
return std::numeric_limits<T>::digits;
}
template <> constexpr int num_bits<fallback_uintptr>() {
return static_cast<int>(sizeof(void*) *
std::numeric_limits<unsigned char>::digits);
}
// An approximation of iterator_t for pre-C++20 systems.
template <typename T>
using iterator_t = decltype(std::begin(std::declval<T&>()));
// Detect the iterator category of *any* given type in a SFINAE-friendly way.
// Unfortunately, older implementations of std::iterator_traits are not safe
// for use in a SFINAE-context.
template <typename It, typename Enable = void>
struct iterator_category : std::false_type {};
template <typename T> struct iterator_category<T*> {
using type = std::random_access_iterator_tag;
};
template <typename It>
struct iterator_category<It, void_t<typename It::iterator_category>> {
using type = typename It::iterator_category;
};
// Detect if *any* given type models the OutputIterator concept.
template <typename It> class is_output_iterator {
// Check for mutability because all iterator categories derived from
// std::input_iterator_tag *may* also meet the requirements of an
// OutputIterator, thereby falling into the category of 'mutable iterators'
// [iterator.requirements.general] clause 4. The compiler reveals this
// property only at the point of *actually dereferencing* the iterator!
template <typename U>
static decltype(*(std::declval<U>())) test(std::input_iterator_tag);
template <typename U> static char& test(std::output_iterator_tag);
template <typename U> static const char& test(...);
using type = decltype(test<It>(typename iterator_category<It>::type{}));
public:
enum { value = !std::is_const<remove_reference_t<type>>::value };
};
// A workaround for std::string not having mutable data() until C++17.
template <typename Char> inline Char* get_data(std::basic_string<Char>& s) {
return &s[0];
}
template <typename Container>
inline typename Container::value_type* get_data(Container& c) {
return c.data();
}
#if defined(_SECURE_SCL) && _SECURE_SCL
// Make a checked iterator to avoid MSVC warnings.
template <typename T> using checked_ptr = stdext::checked_array_iterator<T*>;
template <typename T> checked_ptr<T> make_checked(T* p, std::size_t size) {
return {p, size};
}
#else
template <typename T> using checked_ptr = T*;
template <typename T> inline T* make_checked(T* p, std::size_t) { return p; }
#endif
template <typename Container, FMT_ENABLE_IF(is_contiguous<Container>::value)>
inline checked_ptr<typename Container::value_type> reserve(
std::back_insert_iterator<Container>& it, std::size_t n) {
Container& c = get_container(it);
std::size_t size = c.size();
c.resize(size + n);
return make_checked(get_data(c) + size, n);
}
template <typename Iterator>
inline Iterator& reserve(Iterator& it, std::size_t) {
return it;
}
// An output iterator that counts the number of objects written to it and
// discards them.
class counting_iterator {
private:
std::size_t count_;
public:
using iterator_category = std::output_iterator_tag;
using difference_type = std::ptrdiff_t;
using pointer = void;
using reference = void;
using _Unchecked_type = counting_iterator; // Mark iterator as checked.
struct value_type {
template <typename T> void operator=(const T&) {}
};
counting_iterator() : count_(0) {}
std::size_t count() const { return count_; }
counting_iterator& operator++() {
++count_;
return *this;
}
counting_iterator operator++(int) {
auto it = *this;
++*this;
return it;
}
value_type operator*() const { return {}; }
};
template <typename OutputIt> class truncating_iterator_base {
protected:
OutputIt out_;
std::size_t limit_;
std::size_t count_;
truncating_iterator_base(OutputIt out, std::size_t limit)
: out_(out), limit_(limit), count_(0) {}
public:
using iterator_category = std::output_iterator_tag;
using value_type = typename std::iterator_traits<OutputIt>::value_type;
using difference_type = void;
using pointer = void;
using reference = void;
using _Unchecked_type =
truncating_iterator_base; // Mark iterator as checked.
OutputIt base() const { return out_; }
std::size_t count() const { return count_; }
};
// An output iterator that truncates the output and counts the number of objects
// written to it.
template <typename OutputIt,
typename Enable = typename std::is_void<
typename std::iterator_traits<OutputIt>::value_type>::type>
class truncating_iterator;
template <typename OutputIt>
class truncating_iterator<OutputIt, std::false_type>
: public truncating_iterator_base<OutputIt> {
mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
public:
using value_type = typename truncating_iterator_base<OutputIt>::value_type;
truncating_iterator(OutputIt out, std::size_t limit)
: truncating_iterator_base<OutputIt>(out, limit) {}
truncating_iterator& operator++() {
if (this->count_++ < this->limit_) ++this->out_;
return *this;
}
truncating_iterator operator++(int) {
auto it = *this;
++*this;
return it;
}
value_type& operator*() const {
return this->count_ < this->limit_ ? *this->out_ : blackhole_;
}
};
template <typename OutputIt>
class truncating_iterator<OutputIt, std::true_type>
: public truncating_iterator_base<OutputIt> {
public:
truncating_iterator(OutputIt out, std::size_t limit)
: truncating_iterator_base<OutputIt>(out, limit) {}
template <typename T> truncating_iterator& operator=(T val) {
if (this->count_++ < this->limit_) *this->out_++ = val;
return *this;
}
truncating_iterator& operator++() { return *this; }
truncating_iterator& operator++(int) { return *this; }
truncating_iterator& operator*() { return *this; }
};
// A range with the specified output iterator and value type.
template <typename OutputIt, typename T = typename OutputIt::value_type>
class output_range {
private:
OutputIt it_;
public:
using value_type = T;
using iterator = OutputIt;
struct sentinel {};
explicit output_range(OutputIt it) : it_(it) {}
OutputIt begin() const { return it_; }
sentinel end() const { return {}; } // Sentinel is not used yet.
};
template <typename Char>
inline size_t count_code_points(basic_string_view<Char> s) {
return s.size();
}
// Counts the number of code points in a UTF-8 string.
inline size_t count_code_points(basic_string_view<char> s) {
const char* data = s.data();
size_t num_code_points = 0;
for (size_t i = 0, size = s.size(); i != size; ++i) {
if ((data[i] & 0xc0) != 0x80) ++num_code_points;
}
return num_code_points;
}
inline size_t count_code_points(basic_string_view<char8_type> s) {
return count_code_points(basic_string_view<char>(
reinterpret_cast<const char*>(s.data()), s.size()));
}
template <typename Char>
inline size_t code_point_index(basic_string_view<Char> s, size_t n) {
size_t size = s.size();
return n < size ? n : size;
}
// Calculates the index of the nth code point in a UTF-8 string.
inline size_t code_point_index(basic_string_view<char8_type> s, size_t n) {
const char8_type* data = s.data();
size_t num_code_points = 0;
for (size_t i = 0, size = s.size(); i != size; ++i) {
if ((data[i] & 0xc0) != 0x80 && ++num_code_points > n) {
return i;
}
}
return s.size();
}
inline char8_type to_char8_t(char c) { return static_cast<char8_type>(c); }
template <typename InputIt, typename OutChar>
using needs_conversion = bool_constant<
std::is_same<typename std::iterator_traits<InputIt>::value_type,
char>::value &&
std::is_same<OutChar, char8_type>::value>;
template <typename OutChar, typename InputIt, typename OutputIt,
FMT_ENABLE_IF(!needs_conversion<InputIt, OutChar>::value)>
OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
return std::copy(begin, end, it);
}
template <typename OutChar, typename InputIt, typename OutputIt,
FMT_ENABLE_IF(needs_conversion<InputIt, OutChar>::value)>
OutputIt copy_str(InputIt begin, InputIt end, OutputIt it) {
return std::transform(begin, end, it, to_char8_t);
}
#ifndef FMT_USE_GRISU
# define FMT_USE_GRISU 1
#endif
template <typename T> constexpr bool use_grisu() {
return FMT_USE_GRISU && std::numeric_limits<double>::is_iec559 &&
sizeof(T) <= sizeof(double);
}
template <typename T>
template <typename U>
void buffer<T>::append(const U* begin, const U* end) {
std::size_t new_size = size_ + to_unsigned(end - begin);
reserve(new_size);
std::uninitialized_copy(begin, end, make_checked(ptr_, capacity_) + size_);
size_ = new_size;
}
} // namespace internal
// A range with an iterator appending to a buffer.
template <typename T>
class buffer_range : public internal::output_range<
std::back_insert_iterator<internal::buffer<T>>, T> {
public:
using iterator = std::back_insert_iterator<internal::buffer<T>>;
using internal::output_range<iterator, T>::output_range;
buffer_range(internal::buffer<T>& buf)
: internal::output_range<iterator, T>(std::back_inserter(buf)) {}
};
class FMT_DEPRECATED u8string_view
: public basic_string_view<internal::char8_type> {
public:
u8string_view(const char* s)
: basic_string_view<internal::char8_type>(
reinterpret_cast<const internal::char8_type*>(s)) {}
u8string_view(const char* s, size_t count) FMT_NOEXCEPT
: basic_string_view<internal::char8_type>(
reinterpret_cast<const internal::char8_type*>(s), count) {}
};
#if FMT_USE_USER_DEFINED_LITERALS
inline namespace literals {
FMT_DEPRECATED inline basic_string_view<internal::char8_type> operator"" _u(
const char* s, std::size_t n) {
return {reinterpret_cast<const internal::char8_type*>(s), n};
}
} // namespace literals
#endif
// The number of characters to store in the basic_memory_buffer object itself
// to avoid dynamic memory allocation.
enum { inline_buffer_size = 500 };
/**
\rst
A dynamically growing memory buffer for trivially copyable/constructible types
with the first ``SIZE`` elements stored in the object itself.
You can use one of the following type aliases for common character types:
+----------------+------------------------------+
| Type | Definition |
+================+==============================+
| memory_buffer | basic_memory_buffer<char> |
+----------------+------------------------------+
| wmemory_buffer | basic_memory_buffer<wchar_t> |
+----------------+------------------------------+
**Example**::
fmt::memory_buffer out;
format_to(out, "The answer is {}.", 42);
This will append the following output to the ``out`` object:
.. code-block:: none
The answer is 42.
The output can be converted to an ``std::string`` with ``to_string(out)``.
\endrst
*/
template <typename T, std::size_t SIZE = inline_buffer_size,
typename Allocator = std::allocator<T>>
class basic_memory_buffer : private Allocator, public internal::buffer<T> {
private:
T store_[SIZE];
// Deallocate memory allocated by the buffer.
void deallocate() {
T* data = this->data();
if (data != store_) Allocator::deallocate(data, this->capacity());
}
protected:
void grow(std::size_t size) FMT_OVERRIDE;
public:
using value_type = T;
using const_reference = const T&;
explicit basic_memory_buffer(const Allocator& alloc = Allocator())
: Allocator(alloc) {
this->set(store_, SIZE);
}
~basic_memory_buffer() FMT_OVERRIDE { deallocate(); }
private:
// Move data from other to this buffer.
void move(basic_memory_buffer& other) {
Allocator &this_alloc = *this, &other_alloc = other;
this_alloc = std::move(other_alloc);
T* data = other.data();
std::size_t size = other.size(), capacity = other.capacity();
if (data == other.store_) {
this->set(store_, capacity);
std::uninitialized_copy(other.store_, other.store_ + size,
internal::make_checked(store_, capacity));
} else {
this->set(data, capacity);
gitextract_ns33kz0v/
├── README.md
└── examples/
├── docker/
│ └── gcc13/
│ └── dockerfile
├── lesson01/
│ └── GuessNumber.cpp
├── lesson02/
│ ├── fig02_01.cpp
│ ├── fig02_02.cpp
│ ├── fig02_03.cpp
│ ├── fig02_04.cpp
│ ├── fig02_05.cpp
│ └── fig02_06.cpp
├── lesson03/
│ ├── fig03_01.cpp
│ ├── fig03_02.cpp
│ ├── fig03_03.cpp
│ ├── fig03_04.cpp
│ └── fig03_05.cpp
├── lesson04/
│ ├── decimalformatter.h
│ ├── decimalformatter_fmt.h
│ ├── ex04_06.cpp
│ ├── fig04_01.cpp
│ ├── fig04_02.cpp
│ ├── fig04_03.cpp
│ ├── fig04_03fmt.cpp
│ ├── fig04_04.cpp
│ ├── fig04_04fmt.cpp
│ ├── fig04_05.cpp
│ ├── fig04_06.cpp
│ ├── fig04_06fmt.cpp
│ ├── fig04_07.cpp
│ ├── fig04_07_with_error.cpp
│ ├── fig04_07fmt.cpp
│ ├── fig04_08.cpp
│ ├── fig04_09.cpp
│ ├── fig04_10.cpp
│ ├── fig04_11.cpp
│ ├── fig04_12/
│ │ ├── fig04_12.cpp
│ │ ├── fmt/
│ │ │ ├── core.h
│ │ │ ├── format-inl.h
│ │ │ └── format.h
│ │ └── format.cc
│ ├── fig04_17.cpp
│ └── fig04_17fmt.cpp
├── lesson05/
│ ├── cipher.h
│ ├── ex05_31.cpp
│ ├── fig05_01.cpp
│ ├── fig05_02.cpp
│ ├── fig05_03.cpp
│ ├── fig05_04.cpp
│ ├── fig05_05.cpp
│ ├── fig05_06.cpp
│ ├── fig05_07.cpp
│ ├── fig05_08.cpp
│ ├── fig05_09.cpp
│ ├── fig05_10.cpp
│ ├── fig05_11.cpp
│ ├── fig05_12.cpp
│ ├── fig05_13.cpp
│ ├── fig05_14.cpp
│ ├── fig05_15.cpp
│ ├── fig05_16.cpp
│ ├── fig05_17.cpp
│ ├── fig05_18.cpp
│ ├── fig05_19.cpp
│ ├── fig05_20.cpp
│ └── maximum.h
├── lesson06/
│ ├── fig06_01.cpp
│ ├── fig06_02.cpp
│ ├── fig06_03.cpp
│ ├── fig06_04.cpp
│ ├── fig06_05.cpp
│ ├── fig06_06.cpp
│ ├── fig06_07.cpp
│ ├── fig06_08.cpp
│ ├── fig06_09.cpp
│ ├── fig06_10.cpp
│ ├── fig06_11.cpp
│ ├── fig06_12.cpp
│ ├── fig06_13.cpp
│ └── fig06_14.cpp
├── lesson07/
│ ├── fig07_01.cpp
│ ├── fig07_02.cpp
│ ├── fig07_03.cpp
│ ├── fig07_06.cpp
│ ├── fig07_07.cpp
│ ├── fig07_08.cpp
│ ├── fig07_09.cpp
│ ├── fig07_10.cpp
│ ├── fig07_11.cpp
│ ├── fig07_12.cpp
│ ├── fig07_13.cpp
│ └── fig07_14.cpp
├── lesson08/
│ ├── accounts.csv
│ ├── fig08_01.cpp
│ ├── fig08_02.cpp
│ ├── fig08_03.cpp
│ ├── fig08_04.cpp
│ ├── fig08_05.cpp
│ ├── fig08_06.cpp
│ ├── fig08_07.cpp
│ ├── fig08_08.cpp
│ ├── fig08_09.cpp
│ ├── fig08_10.cpp
│ ├── fig08_11.cpp
│ ├── fig08_12.cpp
│ ├── fig08_13.cpp
│ ├── fig08_14.cpp
│ ├── fig08_15.cpp
│ ├── fig08_16.cpp
│ ├── fig08_17.cpp
│ ├── fig08_18.cpp
│ ├── format.cc
│ └── titanic.csv
├── lesson09/
│ ├── fig09_01-02/
│ │ ├── Account.h
│ │ └── AccountTest.cpp
│ ├── fig09_03-04/
│ │ ├── Account.h
│ │ └── AccountTest.cpp
│ ├── fig09_05-06/
│ │ ├── Account.h
│ │ └── AccountTest.cpp
│ ├── fig09_07-09/
│ │ ├── Time.cpp
│ │ ├── Time.h
│ │ └── fig09_09.cpp
│ ├── fig09_10-12/
│ │ ├── Time.cpp
│ │ ├── Time.h
│ │ └── fig09_12.cpp
│ ├── fig09_13-15/
│ │ ├── CreateAndDestroy.cpp
│ │ ├── CreateAndDestroy.h
│ │ └── fig09_15.cpp
│ ├── fig09_16-18/
│ │ ├── Time.cpp
│ │ ├── Time.h
│ │ └── fig09_18.cpp
│ ├── fig09_19-21/
│ │ ├── Date.cpp
│ │ ├── Date.h
│ │ └── fig09_21.cpp
│ ├── fig09_22/
│ │ ├── Time.cpp
│ │ ├── Time.h
│ │ └── fig09_22.cpp
│ ├── fig09_23-27/
│ │ ├── Date.cpp
│ │ ├── Date.h
│ │ ├── Employee.cpp
│ │ ├── Employee.h
│ │ └── fig09_27.cpp
│ ├── fig09_28/
│ │ └── fig09_28.cpp
│ ├── fig09_29/
│ │ └── fig09_29.cpp
│ ├── fig09_30-32/
│ │ ├── Time.cpp
│ │ ├── Time.h
│ │ └── fig09_32.cpp
│ ├── fig09_33-35/
│ │ ├── Employee.cpp
│ │ ├── Employee.h
│ │ └── fig09_35.cpp
│ ├── fig09_36-37/
│ │ ├── cipher.h
│ │ └── fig09_36.cpp
│ └── fig09_38/
│ ├── fig09_38.cpp
│ └── records.json
├── lesson10/
│ ├── fig10_01-03/
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_03.cpp
│ ├── fig10_04-06/
│ │ ├── SalariedCommissionEmployee.cpp
│ │ ├── SalariedCommissionEmployee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_06.cpp
│ ├── fig10_07/
│ │ ├── SalariedCommissionEmployee.cpp
│ │ ├── SalariedCommissionEmployee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_07.cpp
│ ├── fig10_08/
│ │ ├── SalariedCommissionEmployee.cpp
│ │ ├── SalariedCommissionEmployee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_08.cpp
│ ├── fig10_09/
│ │ ├── SalariedCommissionEmployee.cpp
│ │ ├── SalariedCommissionEmployee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_09.cpp
│ ├── fig10_10/
│ │ ├── SalariedCommissionEmployee.cpp
│ │ ├── SalariedCommissionEmployee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_10.cpp
│ ├── fig10_11-17/
│ │ ├── CommissionEmployee.cpp
│ │ ├── CommissionEmployee.h
│ │ ├── Employee.cpp
│ │ ├── Employee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig10_17.cpp
│ └── fig10_19-26/
│ ├── Commission.cpp
│ ├── Commission.h
│ ├── CompensationModel.h
│ ├── Employee.cpp
│ ├── Employee.h
│ ├── Salaried.cpp
│ ├── Salaried.h
│ └── fig10_26.cpp
├── lesson11/
│ ├── fig11_01/
│ │ └── fig11_01.cpp
│ ├── fig11_02/
│ │ └── fig11_02.cpp
│ ├── fig11_03-05/
│ │ ├── MyArray.cpp
│ │ ├── MyArray.h
│ │ ├── a.out
│ │ └── fig11_03.cpp
│ ├── fig11_06/
│ │ └── fig11_06.cpp
│ ├── fig11_07/
│ │ ├── MyArray.cpp
│ │ ├── MyArray.h
│ │ └── fig11_07.cpp
│ └── fig11_08/
│ ├── MyArray.cpp
│ ├── MyArray.h
│ └── fig11_08.cpp
├── lesson12/
│ ├── fig12_01-02/
│ │ ├── DivideByZeroException.h
│ │ └── fig12_02.cpp
│ ├── fig12_03/
│ │ └── fig12_03.cpp
│ ├── fig12_04/
│ │ ├── fig12_04.cpp
│ │ └── fig12_04modified.cpp
│ ├── fig12_05/
│ │ └── fig12_05.cpp
│ ├── fig12_06/
│ │ └── fig12_06.cpp
│ ├── fig12_07/
│ │ └── fig12_07.cpp
│ ├── fig12_08/
│ │ └── fig12_08.cpp
│ └── fig12_09/
│ └── fig12_09.cpp
├── lesson13/
│ ├── fig13_01.cpp
│ ├── fig13_02.cpp
│ ├── fig13_03.cpp
│ ├── fig13_04.cpp
│ ├── fig13_05.cpp
│ ├── fig13_06.cpp
│ ├── fig13_07.cpp
│ ├── fig13_08.cpp
│ ├── fig13_09.cpp
│ ├── fig13_10.cpp
│ ├── fig13_11.cpp
│ └── fig13_12.cpp
├── lesson14/
│ ├── fig14_01.cpp
│ ├── fig14_02.cpp
│ ├── fig14_03.cpp
│ ├── fig14_04.cpp
│ ├── fig14_05.cpp
│ ├── fig14_06.cpp
│ ├── fig14_07.cpp
│ ├── fig14_08.cpp
│ ├── fig14_09.cpp
│ ├── fig14_10.cpp
│ ├── fig14_11.cpp
│ ├── fig14_12.cpp
│ ├── fig14_13.cpp
│ ├── fig14_14.cpp
│ ├── fig14_15.cpp
│ ├── fig14_16.cpp
│ ├── fig14_17.cpp
│ └── fig14_18.cpp
├── lesson15/
│ ├── fig15_01-02/
│ │ ├── Stack.h
│ │ └── fig15_02.cpp
│ ├── fig15_03.cpp
│ ├── fig15_04.cpp
│ ├── fig15_05.cpp
│ ├── fig15_06.cpp
│ ├── fig15_07.cpp
│ ├── fig15_08.cpp
│ ├── fig15_09.cpp
│ ├── fig15_10.cpp
│ ├── fig15_11-12/
│ │ ├── MyArray.h
│ │ ├── fig15_12.cpp
│ │ └── sorttest.cpp
│ ├── fig15_13.cpp
│ ├── fig15_14.cpp
│ ├── fig15_15.cpp
│ ├── fig15_16.cpp
│ ├── fig15_17.cpp
│ ├── fig15_18.cpp
│ ├── fig15_19.cpp
│ ├── fig15_20.cpp
│ └── fig15_21.cpp
├── lesson16/
│ ├── compilation_commands.txt
│ ├── fig16_01/
│ │ └── fig16_01.cpp
│ ├── fig16_02-03/
│ │ ├── fig16_03.cpp
│ │ └── welcome.ixx
│ ├── fig16_04-05/
│ │ ├── deitel.math.ixx
│ │ └── fig16_05.cpp
│ ├── fig16_06-08/
│ │ ├── deitel.math-impl.cpp
│ │ ├── deitel.math.ixx
│ │ └── fig16_08.cpp
│ ├── fig16_09-11/
│ │ ├── deitel.time-impl.cpp
│ │ ├── deitel.time.ixx
│ │ └── fig16_11.cpp
│ ├── fig16_12-15/
│ │ ├── deitel.math-powers.ixx
│ │ ├── deitel.math-roots.ixx
│ │ ├── deitel.math.ixx
│ │ └── fig16_15.cpp
│ ├── fig16_12-15clang/
│ │ ├── deitel.math-powers.ixx
│ │ ├── deitel.math-roots.ixx
│ │ ├── deitel.math.ixx
│ │ └── fig16_15.cpp
│ ├── fig16_16-21/
│ │ ├── deitel.math.ixx
│ │ ├── deitel.math.powers.ixx
│ │ ├── deitel.math.roots.ixx
│ │ ├── fig16_17.cpp
│ │ ├── fig16_19.cpp
│ │ └── fig16_21.cpp
│ ├── fig16_16-21clang/
│ │ ├── deitel.math.ixx
│ │ ├── deitel.math.powers.ixx
│ │ ├── deitel.math.roots.ixx
│ │ ├── fig16_17.cpp
│ │ ├── fig16_19.cpp
│ │ └── fig16_21.cpp
│ ├── fig16_22/
│ │ └── fig16_22.cpp
│ ├── fig16_23-24/
│ │ ├── moduleA.ixx
│ │ └── moduleB.ixx
│ ├── fig16_25-27/
│ │ ├── fig16_27.cpp
│ │ ├── moduleA.ixx
│ │ └── moduleB.ixx
│ └── fig16_28-29/
│ ├── deitel.time-impl.cpp
│ ├── deitel.time.ixx
│ └── fig16_29.cpp
├── lesson17/
│ ├── fig17_01/
│ │ └── fig17_01.cpp
│ ├── fig17_02/
│ │ └── fig17_02.cpp
│ ├── fig17_03-04/
│ │ ├── printtask.cpp
│ │ └── printtask.h
│ ├── fig17_05-06/
│ │ ├── SharedBufferTest.cpp
│ │ └── UnsynchronizedBuffer.h
│ ├── fig17_07-08/
│ │ ├── SharedBufferTest.cpp
│ │ └── SynchronizedBuffer.h
│ ├── fig17_09-10/
│ │ ├── CircularBuffer.h
│ │ └── SharedBufferTest.cpp
│ ├── fig17_11/
│ │ ├── CooperativeCancelation.cpp
│ │ └── CooperativeCancelationFMT.cpp
│ ├── fig17_12/
│ │ ├── async.cpp
│ │ ├── async.o
│ │ └── format.o
│ ├── fig17_13/
│ │ └── atomic.cpp
│ ├── fig17_14/
│ │ └── LatchDemo.cpp
│ ├── fig17_15/
│ │ └── BarrierDemo.cpp
│ └── fig17_16/
│ ├── SharedBufferTest.cpp
│ └── SynchronizedBuffer.h
├── lesson18/
│ ├── fig18_01.cpp
│ ├── fig18_02.cpp
│ ├── fig18_03.cpp
│ └── vcpkg.json
├── lesson19/
│ ├── fig19_01.cpp
│ ├── fig19_02.cpp
│ ├── fig19_03.cpp
│ ├── fig19_04.cpp
│ ├── fig19_05.cpp
│ ├── fig19_06.cpp
│ ├── fig19_07.cpp
│ ├── fig19_08.cpp
│ ├── fig19_09.cpp
│ ├── fig19_10.cpp
│ ├── fig19_11.cpp
│ ├── fig19_12.cpp
│ ├── fig19_13.cpp
│ ├── fig19_14.cpp
│ ├── fig19_15.cpp
│ ├── fig19_16.cpp
│ ├── fig19_17.cpp
│ ├── fig19_18.cpp
│ ├── fig19_19.cpp
│ ├── fig19_20.cpp
│ ├── fig19_21.cpp
│ ├── fig19_22.cpp
│ └── fig19_23.cpp
├── lesson20/
│ ├── fig20_01.cpp
│ ├── fig20_02.cpp
│ ├── fig20_03.cpp
│ ├── fig20_04.cpp
│ ├── fig20_05.cpp
│ ├── fig20_06/
│ │ ├── CommissionEmployee.cpp
│ │ ├── CommissionEmployee.h
│ │ ├── Employee.cpp
│ │ ├── Employee.h
│ │ ├── SalariedEmployee.cpp
│ │ ├── SalariedEmployee.h
│ │ └── fig20_06.cpp
│ ├── fig20_07.cpp
│ ├── fig20_08.cpp
│ ├── fig20_09-13/
│ │ ├── Author.cpp
│ │ ├── Author.h
│ │ ├── Book.cpp
│ │ ├── Book.h
│ │ └── fig20_13.cpp
│ └── fig20_14.cpp
├── libraries/
│ ├── BigNumber/
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE.md
│ │ ├── README.md
│ │ ├── bin/
│ │ │ └── BigNumber/
│ │ │ ├── include/
│ │ │ │ └── bignumber.h
│ │ │ └── lib/
│ │ │ └── libBigNumber.a
│ │ ├── main.cpp
│ │ └── src/
│ │ ├── bignumber.cpp
│ │ └── bignumber.h
│ ├── GSL/
│ │ ├── .clang-format
│ │ ├── .github/
│ │ │ └── workflows/
│ │ │ └── main.yml
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── CMakeLists.txt
│ │ ├── CMakeSettings.json
│ │ ├── CONTRIBUTING.md
│ │ ├── GSL.natvis
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── ThirdPartyNotices.txt
│ │ ├── appveyor.yml
│ │ ├── include/
│ │ │ └── gsl/
│ │ │ ├── gsl
│ │ │ ├── gsl_algorithm
│ │ │ ├── gsl_assert
│ │ │ ├── gsl_byte
│ │ │ ├── gsl_util
│ │ │ ├── multi_span
│ │ │ ├── pointers
│ │ │ ├── span
│ │ │ ├── span_ext
│ │ │ └── string_span
│ │ └── tests/
│ │ ├── CMakeLists.txt
│ │ ├── CMakeLists.txt.in
│ │ ├── algorithm_tests.cpp
│ │ ├── assertion_tests.cpp
│ │ ├── at_tests.cpp
│ │ ├── bounds_tests.cpp
│ │ ├── byte_tests.cpp
│ │ ├── multi_span_tests.cpp
│ │ ├── no_exception_ensure_tests.cpp
│ │ ├── notnull_tests.cpp
│ │ ├── owner_tests.cpp
│ │ ├── span_compatibility_tests.cpp
│ │ ├── span_ext_tests.cpp
│ │ ├── span_tests.cpp
│ │ ├── strict_notnull_tests.cpp
│ │ ├── strided_span_tests.cpp
│ │ ├── string_span_tests.cpp
│ │ └── utils_tests.cpp
│ ├── cereal-1.3.0/
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── appveyor.yml
│ │ ├── doc/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── DoxygenLayout.xml
│ │ │ ├── doxygen.in
│ │ │ ├── footer.html
│ │ │ └── mainpage.dox
│ │ ├── include/
│ │ │ └── cereal/
│ │ │ ├── access.hpp
│ │ │ ├── archives/
│ │ │ │ ├── adapters.hpp
│ │ │ │ ├── binary.hpp
│ │ │ │ ├── json.hpp
│ │ │ │ ├── portable_binary.hpp
│ │ │ │ └── xml.hpp
│ │ │ ├── cereal.hpp
│ │ │ ├── details/
│ │ │ │ ├── helpers.hpp
│ │ │ │ ├── polymorphic_impl.hpp
│ │ │ │ ├── polymorphic_impl_fwd.hpp
│ │ │ │ ├── static_object.hpp
│ │ │ │ ├── traits.hpp
│ │ │ │ └── util.hpp
│ │ │ ├── external/
│ │ │ │ ├── base64.hpp
│ │ │ │ ├── rapidjson/
│ │ │ │ │ ├── allocators.h
│ │ │ │ │ ├── cursorstreamwrapper.h
│ │ │ │ │ ├── document.h
│ │ │ │ │ ├── encodedstream.h
│ │ │ │ │ ├── encodings.h
│ │ │ │ │ ├── error/
│ │ │ │ │ │ ├── en.h
│ │ │ │ │ │ └── error.h
│ │ │ │ │ ├── filereadstream.h
│ │ │ │ │ ├── filewritestream.h
│ │ │ │ │ ├── fwd.h
│ │ │ │ │ ├── internal/
│ │ │ │ │ │ ├── biginteger.h
│ │ │ │ │ │ ├── diyfp.h
│ │ │ │ │ │ ├── dtoa.h
│ │ │ │ │ │ ├── ieee754.h
│ │ │ │ │ │ ├── itoa.h
│ │ │ │ │ │ ├── meta.h
│ │ │ │ │ │ ├── pow10.h
│ │ │ │ │ │ ├── regex.h
│ │ │ │ │ │ ├── stack.h
│ │ │ │ │ │ ├── strfunc.h
│ │ │ │ │ │ ├── strtod.h
│ │ │ │ │ │ └── swap.h
│ │ │ │ │ ├── istreamwrapper.h
│ │ │ │ │ ├── memorybuffer.h
│ │ │ │ │ ├── memorystream.h
│ │ │ │ │ ├── msinttypes/
│ │ │ │ │ │ ├── inttypes.h
│ │ │ │ │ │ └── stdint.h
│ │ │ │ │ ├── ostreamwrapper.h
│ │ │ │ │ ├── pointer.h
│ │ │ │ │ ├── prettywriter.h
│ │ │ │ │ ├── rapidjson.h
│ │ │ │ │ ├── reader.h
│ │ │ │ │ ├── schema.h
│ │ │ │ │ ├── stream.h
│ │ │ │ │ ├── stringbuffer.h
│ │ │ │ │ └── writer.h
│ │ │ │ └── rapidxml/
│ │ │ │ ├── license.txt
│ │ │ │ ├── manual.html
│ │ │ │ ├── rapidxml.hpp
│ │ │ │ ├── rapidxml_iterators.hpp
│ │ │ │ ├── rapidxml_print.hpp
│ │ │ │ └── rapidxml_utils.hpp
│ │ │ ├── macros.hpp
│ │ │ ├── specialize.hpp
│ │ │ ├── types/
│ │ │ │ ├── array.hpp
│ │ │ │ ├── atomic.hpp
│ │ │ │ ├── base_class.hpp
│ │ │ │ ├── bitset.hpp
│ │ │ │ ├── boost_variant.hpp
│ │ │ │ ├── chrono.hpp
│ │ │ │ ├── common.hpp
│ │ │ │ ├── complex.hpp
│ │ │ │ ├── concepts/
│ │ │ │ │ └── pair_associative_container.hpp
│ │ │ │ ├── deque.hpp
│ │ │ │ ├── forward_list.hpp
│ │ │ │ ├── functional.hpp
│ │ │ │ ├── list.hpp
│ │ │ │ ├── map.hpp
│ │ │ │ ├── memory.hpp
│ │ │ │ ├── optional.hpp
│ │ │ │ ├── polymorphic.hpp
│ │ │ │ ├── queue.hpp
│ │ │ │ ├── set.hpp
│ │ │ │ ├── stack.hpp
│ │ │ │ ├── string.hpp
│ │ │ │ ├── tuple.hpp
│ │ │ │ ├── unordered_map.hpp
│ │ │ │ ├── unordered_set.hpp
│ │ │ │ ├── utility.hpp
│ │ │ │ ├── valarray.hpp
│ │ │ │ ├── variant.hpp
│ │ │ │ └── vector.hpp
│ │ │ └── version.hpp
│ │ ├── sandbox/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── performance.cpp
│ │ │ ├── sandbox.cpp
│ │ │ ├── sandbox_json.cpp
│ │ │ ├── sandbox_rtti.cpp
│ │ │ ├── sandbox_shared_lib/
│ │ │ │ ├── CMakeLists.txt
│ │ │ │ ├── base.cpp
│ │ │ │ ├── base.hpp
│ │ │ │ ├── derived.cpp
│ │ │ │ └── derived.hpp
│ │ │ └── sandbox_vs.cpp
│ │ ├── scripts/
│ │ │ ├── add_rapidjson_prefix.sh
│ │ │ ├── appveyor.bat
│ │ │ ├── renameincludes.sh
│ │ │ ├── updatecoverage.sh
│ │ │ └── updatedoc.in
│ │ └── unittests/
│ │ ├── CMakeLists.txt
│ │ ├── array.cpp
│ │ ├── array.hpp
│ │ ├── atomic.cpp
│ │ ├── atomic.hpp
│ │ ├── basic_string.cpp
│ │ ├── basic_string.hpp
│ │ ├── bitset.cpp
│ │ ├── bitset.hpp
│ │ ├── boost/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── boost_variant.cpp
│ │ │ └── boost_variant.hpp
│ │ ├── chrono.cpp
│ │ ├── chrono.hpp
│ │ ├── cmake-config-module.cmake
│ │ ├── common.hpp
│ │ ├── complex.cpp
│ │ ├── complex.hpp
│ │ ├── cpp17/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── optional.cpp
│ │ │ ├── optional.hpp
│ │ │ ├── variant.cpp
│ │ │ └── variant.hpp
│ │ ├── defer.cpp
│ │ ├── defer.hpp
│ │ ├── deque.cpp
│ │ ├── deque.hpp
│ │ ├── doctest.h
│ │ ├── forward_list.cpp
│ │ ├── forward_list.hpp
│ │ ├── list.cpp
│ │ ├── list.hpp
│ │ ├── load_construct.cpp
│ │ ├── load_construct.hpp
│ │ ├── map.cpp
│ │ ├── map.hpp
│ │ ├── memory.cpp
│ │ ├── memory.hpp
│ │ ├── memory_cycles.cpp
│ │ ├── memory_cycles.hpp
│ │ ├── multimap.cpp
│ │ ├── multimap.hpp
│ │ ├── multiset.cpp
│ │ ├── multiset.hpp
│ │ ├── pair.cpp
│ │ ├── pair.hpp
│ │ ├── pod.cpp
│ │ ├── pod.hpp
│ │ ├── polymorphic.cpp
│ │ ├── polymorphic.hpp
│ │ ├── portability_test.cpp
│ │ ├── portable_binary_archive.cpp
│ │ ├── portable_binary_archive.hpp
│ │ ├── priority_queue.cpp
│ │ ├── priority_queue.hpp
│ │ ├── queue.cpp
│ │ ├── queue.hpp
│ │ ├── run_portability_test.cmake
│ │ ├── run_valgrind.sh
│ │ ├── set.cpp
│ │ ├── set.hpp
│ │ ├── stack.cpp
│ │ ├── stack.hpp
│ │ ├── structs.cpp
│ │ ├── structs.hpp
│ │ ├── structs_minimal.cpp
│ │ ├── structs_minimal.hpp
│ │ ├── structs_specialized.cpp
│ │ ├── structs_specialized.hpp
│ │ ├── tuple.cpp
│ │ ├── tuple.hpp
│ │ ├── unordered_loads.cpp
│ │ ├── unordered_loads.hpp
│ │ ├── unordered_map.cpp
│ │ ├── unordered_map.hpp
│ │ ├── unordered_multimap.cpp
│ │ ├── unordered_multimap.hpp
│ │ ├── unordered_multiset.cpp
│ │ ├── unordered_multiset.hpp
│ │ ├── unordered_set.cpp
│ │ ├── unordered_set.hpp
│ │ ├── user_data_adapters.cpp
│ │ ├── user_data_adapters.hpp
│ │ ├── valarray.cpp
│ │ ├── valarray.hpp
│ │ ├── vector.cpp
│ │ ├── vector.hpp
│ │ ├── versioning.cpp
│ │ └── versioning.hpp
│ ├── fmt/
│ │ ├── .clang-format
│ │ ├── .github/
│ │ │ ├── pull_request_template.md
│ │ │ └── workflows/
│ │ │ ├── doc.yml
│ │ │ ├── linux.yml
│ │ │ ├── macos.yml
│ │ │ └── windows.yml
│ │ ├── .gitignore
│ │ ├── CMakeLists.txt
│ │ ├── CONTRIBUTING.md
│ │ ├── ChangeLog.rst
│ │ ├── LICENSE.rst
│ │ ├── README.rst
│ │ ├── doc/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── _static/
│ │ │ │ └── breathe.css
│ │ │ ├── _templates/
│ │ │ │ ├── layout.html
│ │ │ │ └── search.html
│ │ │ ├── api.rst
│ │ │ ├── basic-bootstrap/
│ │ │ │ ├── README
│ │ │ │ ├── layout.html
│ │ │ │ └── theme.conf
│ │ │ ├── bootstrap/
│ │ │ │ ├── alerts.less
│ │ │ │ ├── badges.less
│ │ │ │ ├── bootstrap.less
│ │ │ │ ├── breadcrumbs.less
│ │ │ │ ├── button-groups.less
│ │ │ │ ├── buttons.less
│ │ │ │ ├── carousel.less
│ │ │ │ ├── close.less
│ │ │ │ ├── code.less
│ │ │ │ ├── component-animations.less
│ │ │ │ ├── dropdowns.less
│ │ │ │ ├── forms.less
│ │ │ │ ├── glyphicons.less
│ │ │ │ ├── grid.less
│ │ │ │ ├── input-groups.less
│ │ │ │ ├── jumbotron.less
│ │ │ │ ├── labels.less
│ │ │ │ ├── list-group.less
│ │ │ │ ├── media.less
│ │ │ │ ├── mixins/
│ │ │ │ │ ├── alerts.less
│ │ │ │ │ ├── background-variant.less
│ │ │ │ │ ├── border-radius.less
│ │ │ │ │ ├── buttons.less
│ │ │ │ │ ├── center-block.less
│ │ │ │ │ ├── clearfix.less
│ │ │ │ │ ├── forms.less
│ │ │ │ │ ├── gradients.less
│ │ │ │ │ ├── grid-framework.less
│ │ │ │ │ ├── grid.less
│ │ │ │ │ ├── hide-text.less
│ │ │ │ │ ├── image.less
│ │ │ │ │ ├── labels.less
│ │ │ │ │ ├── list-group.less
│ │ │ │ │ ├── nav-divider.less
│ │ │ │ │ ├── nav-vertical-align.less
│ │ │ │ │ ├── opacity.less
│ │ │ │ │ ├── pagination.less
│ │ │ │ │ ├── panels.less
│ │ │ │ │ ├── progress-bar.less
│ │ │ │ │ ├── reset-filter.less
│ │ │ │ │ ├── resize.less
│ │ │ │ │ ├── responsive-visibility.less
│ │ │ │ │ ├── size.less
│ │ │ │ │ ├── tab-focus.less
│ │ │ │ │ ├── table-row.less
│ │ │ │ │ ├── text-emphasis.less
│ │ │ │ │ ├── text-overflow.less
│ │ │ │ │ └── vendor-prefixes.less
│ │ │ │ ├── mixins.less
│ │ │ │ ├── modals.less
│ │ │ │ ├── navbar.less
│ │ │ │ ├── navs.less
│ │ │ │ ├── normalize.less
│ │ │ │ ├── pager.less
│ │ │ │ ├── pagination.less
│ │ │ │ ├── panels.less
│ │ │ │ ├── popovers.less
│ │ │ │ ├── print.less
│ │ │ │ ├── progress-bars.less
│ │ │ │ ├── responsive-embed.less
│ │ │ │ ├── responsive-utilities.less
│ │ │ │ ├── scaffolding.less
│ │ │ │ ├── tables.less
│ │ │ │ ├── theme.less
│ │ │ │ ├── thumbnails.less
│ │ │ │ ├── tooltip.less
│ │ │ │ ├── type.less
│ │ │ │ ├── utilities.less
│ │ │ │ ├── variables.less
│ │ │ │ └── wells.less
│ │ │ ├── build.py
│ │ │ ├── conf.py
│ │ │ ├── contents.rst
│ │ │ ├── fmt.less
│ │ │ ├── index.rst
│ │ │ ├── python-license.txt
│ │ │ ├── syntax.rst
│ │ │ └── usage.rst
│ │ ├── include/
│ │ │ └── fmt/
│ │ │ ├── args.h
│ │ │ ├── chrono.h
│ │ │ ├── color.h
│ │ │ ├── compile.h
│ │ │ ├── core.h
│ │ │ ├── format-inl.h
│ │ │ ├── format.h
│ │ │ ├── locale.h
│ │ │ ├── os.h
│ │ │ ├── ostream.h
│ │ │ ├── printf.h
│ │ │ ├── ranges.h
│ │ │ └── xchar.h
│ │ ├── src/
│ │ │ ├── fmt.cc
│ │ │ ├── format.cc
│ │ │ └── os.cc
│ │ ├── support/
│ │ │ ├── Android.mk
│ │ │ ├── AndroidManifest.xml
│ │ │ ├── C++.sublime-syntax
│ │ │ ├── README
│ │ │ ├── Vagrantfile
│ │ │ ├── appveyor-build.py
│ │ │ ├── appveyor.yml
│ │ │ ├── build-docs.py
│ │ │ ├── build.gradle
│ │ │ ├── cmake/
│ │ │ │ ├── FindSetEnv.cmake
│ │ │ │ ├── JoinPaths.cmake
│ │ │ │ ├── cxx14.cmake
│ │ │ │ ├── fmt-config.cmake.in
│ │ │ │ └── fmt.pc.in
│ │ │ ├── compute-powers.py
│ │ │ ├── docopt.py
│ │ │ ├── manage.py
│ │ │ ├── rst2md.py
│ │ │ └── rtd/
│ │ │ ├── conf.py
│ │ │ ├── index.rst
│ │ │ └── theme/
│ │ │ ├── layout.html
│ │ │ └── theme.conf
│ │ └── test/
│ │ ├── CMakeLists.txt
│ │ ├── add-subdirectory-test/
│ │ │ ├── CMakeLists.txt
│ │ │ └── main.cc
│ │ ├── args-test.cc
│ │ ├── assert-test.cc
│ │ ├── chrono-test.cc
│ │ ├── color-test.cc
│ │ ├── compile-error-test/
│ │ │ └── CMakeLists.txt
│ │ ├── compile-test.cc
│ │ ├── core-test.cc
│ │ ├── cuda-test/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── cpp14.cc
│ │ │ └── cuda-cpp14.cu
│ │ ├── enforce-checks-test.cc
│ │ ├── find-package-test/
│ │ │ ├── CMakeLists.txt
│ │ │ └── main.cc
│ │ ├── format
│ │ ├── format-impl-test.cc
│ │ ├── format-test.cc
│ │ ├── fuzzing/
│ │ │ ├── .gitignore
│ │ │ ├── CMakeLists.txt
│ │ │ ├── README.md
│ │ │ ├── build.sh
│ │ │ ├── chrono-duration.cc
│ │ │ ├── float.cc
│ │ │ ├── fuzzer-common.h
│ │ │ ├── main.cc
│ │ │ ├── named-arg.cc
│ │ │ ├── one-arg.cc
│ │ │ └── two-args.cc
│ │ ├── gtest/
│ │ │ ├── .clang-format
│ │ │ ├── CMakeLists.txt
│ │ │ ├── gmock/
│ │ │ │ └── gmock.h
│ │ │ ├── gmock-gtest-all.cc
│ │ │ └── gtest/
│ │ │ ├── gtest-spi.h
│ │ │ └── gtest.h
│ │ ├── gtest-extra-test.cc
│ │ ├── gtest-extra.cc
│ │ ├── gtest-extra.h
│ │ ├── header-only-test.cc
│ │ ├── mock-allocator.h
│ │ ├── module-test.cc
│ │ ├── os-test.cc
│ │ ├── ostream-test.cc
│ │ ├── posix-mock-test.cc
│ │ ├── posix-mock.h
│ │ ├── printf-test.cc
│ │ ├── ranges-test.cc
│ │ ├── scan-test.cc
│ │ ├── scan.h
│ │ ├── static-export-test/
│ │ │ ├── CMakeLists.txt
│ │ │ ├── library.cc
│ │ │ └── main.cc
│ │ ├── std-format-test.cc
│ │ ├── test-assert.h
│ │ ├── test-main.cc
│ │ ├── unicode-test.cc
│ │ ├── util.cc
│ │ ├── util.h
│ │ └── xchar-test.cc
│ ├── multiprecision-Boost_1_81_0/
│ │ ├── .circleci/
│ │ │ └── config.yml
│ │ ├── .clang-format
│ │ ├── .drone/
│ │ │ ├── after-success.sh
│ │ │ ├── before-install.sh
│ │ │ ├── before-script.sh
│ │ │ └── boost.sh
│ │ ├── .drone.star
│ │ ├── .gitattributes
│ │ ├── .github/
│ │ │ └── workflows/
│ │ │ └── multiprecision.yml
│ │ ├── .gitignore
│ │ ├── CMakeLists.txt
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── config/
│ │ │ ├── Jamfile.v2
│ │ │ ├── has_big_obj.cpp
│ │ │ ├── has_constexpr_limits_cmd.cpp
│ │ │ ├── has_eigen.cpp
│ │ │ ├── has_f2c.cpp
│ │ │ ├── has_float128.cpp
│ │ │ ├── has_gmp.cpp
│ │ │ ├── has_intel_quad.cpp
│ │ │ ├── has_is_constant_evaluated.cpp
│ │ │ ├── has_mpc.cpp
│ │ │ ├── has_mpfi.cpp
│ │ │ ├── has_mpfr.cpp
│ │ │ ├── has_tommath.cpp
│ │ │ └── is_ci_sanitizer_run.cpp
│ │ ├── doc/
│ │ │ ├── Jamfile.v2
│ │ │ ├── floating_point_eg1.mml
│ │ │ ├── floating_point_eg2.mml
│ │ │ ├── floating_point_eg3.mml
│ │ │ ├── generate.sh
│ │ │ ├── history.qbk
│ │ │ ├── html/
│ │ │ │ ├── boost_multiprecision/
│ │ │ │ │ ├── indexes/
│ │ │ │ │ │ ├── s01.html
│ │ │ │ │ │ ├── s02.html
│ │ │ │ │ │ ├── s03.html
│ │ │ │ │ │ └── s04.html
│ │ │ │ │ ├── indexes.html
│ │ │ │ │ ├── intro.html
│ │ │ │ │ ├── map/
│ │ │ │ │ │ ├── ack.html
│ │ │ │ │ │ ├── faq.html
│ │ │ │ │ │ ├── hist.html
│ │ │ │ │ │ └── todo.html
│ │ │ │ │ ├── map.html
│ │ │ │ │ ├── perf/
│ │ │ │ │ │ ├── float_performance.html
│ │ │ │ │ │ ├── int_real_world.html
│ │ │ │ │ │ ├── integer_performance.html
│ │ │ │ │ │ ├── overhead.html
│ │ │ │ │ │ ├── rational_performance.html
│ │ │ │ │ │ ├── rational_real_world.html
│ │ │ │ │ │ └── realworld.html
│ │ │ │ │ ├── perf.html
│ │ │ │ │ ├── ref/
│ │ │ │ │ │ ├── backendconc.html
│ │ │ │ │ │ ├── cpp_bin_float_ref.html
│ │ │ │ │ │ ├── cpp_dec_ref.html
│ │ │ │ │ │ ├── cpp_int_ref.html
│ │ │ │ │ │ ├── gmp_int_ref.html
│ │ │ │ │ │ ├── headers.html
│ │ │ │ │ │ ├── internals.html
│ │ │ │ │ │ ├── mpf_ref.html
│ │ │ │ │ │ ├── mpfr_ref.html
│ │ │ │ │ │ ├── number.html
│ │ │ │ │ │ └── tom_int_ref.html
│ │ │ │ │ ├── ref.html
│ │ │ │ │ ├── tut/
│ │ │ │ │ │ ├── complex/
│ │ │ │ │ │ │ ├── complex128.html
│ │ │ │ │ │ │ ├── complex_adaptor.html
│ │ │ │ │ │ │ ├── cpp_complex.html
│ │ │ │ │ │ │ └── mpc_complex.html
│ │ │ │ │ │ ├── complex.html
│ │ │ │ │ │ ├── conversions.html
│ │ │ │ │ │ ├── eigen.html
│ │ │ │ │ │ ├── floats/
│ │ │ │ │ │ │ ├── cpp_bin_float.html
│ │ │ │ │ │ │ ├── cpp_dec_float.html
│ │ │ │ │ │ │ ├── float128.html
│ │ │ │ │ │ │ ├── fp_eg/
│ │ │ │ │ │ │ │ ├── aos.html
│ │ │ │ │ │ │ │ ├── caveats.html
│ │ │ │ │ │ │ │ ├── floatbuiltinctor.html
│ │ │ │ │ │ │ │ ├── gauss_lagerre_quadrature.html
│ │ │ │ │ │ │ │ ├── gi.html
│ │ │ │ │ │ │ │ ├── jel.html
│ │ │ │ │ │ │ │ ├── nd.html
│ │ │ │ │ │ │ │ ├── poly_eg.html
│ │ │ │ │ │ │ │ └── variable_precision.html
│ │ │ │ │ │ │ ├── fp_eg.html
│ │ │ │ │ │ │ ├── gmp_float.html
│ │ │ │ │ │ │ └── mpfr_float.html
│ │ │ │ │ │ ├── floats.html
│ │ │ │ │ │ ├── gen_int.html
│ │ │ │ │ │ ├── hash.html
│ │ │ │ │ │ ├── import_export.html
│ │ │ │ │ │ ├── input_output.html
│ │ │ │ │ │ ├── interval/
│ │ │ │ │ │ │ └── mpfi.html
│ │ │ │ │ │ ├── interval.html
│ │ │ │ │ │ ├── ints/
│ │ │ │ │ │ │ ├── cpp_int.html
│ │ │ │ │ │ │ ├── egs/
│ │ │ │ │ │ │ │ ├── bitops.html
│ │ │ │ │ │ │ │ └── factorials.html
│ │ │ │ │ │ │ ├── egs.html
│ │ │ │ │ │ │ ├── gmp_int.html
│ │ │ │ │ │ │ └── tom_int.html
│ │ │ │ │ │ ├── ints.html
│ │ │ │ │ │ ├── limits/
│ │ │ │ │ │ │ ├── constants.html
│ │ │ │ │ │ │ ├── functions.html
│ │ │ │ │ │ │ ├── how_to_tell.html
│ │ │ │ │ │ │ └── limits32.html
│ │ │ │ │ │ ├── limits.html
│ │ │ │ │ │ ├── lits.html
│ │ │ │ │ │ ├── misc/
│ │ │ │ │ │ │ ├── debug_adaptor.html
│ │ │ │ │ │ │ ├── logged_adaptor.html
│ │ │ │ │ │ │ └── visualizers.html
│ │ │ │ │ │ ├── misc.html
│ │ │ │ │ │ ├── mixed.html
│ │ │ │ │ │ ├── new_backend.html
│ │ │ │ │ │ ├── primetest.html
│ │ │ │ │ │ ├── random.html
│ │ │ │ │ │ ├── rational/
│ │ │ │ │ │ │ ├── cpp_rational.html
│ │ │ │ │ │ │ ├── gmp_rational.html
│ │ │ │ │ │ │ ├── rational_adaptor.html
│ │ │ │ │ │ │ ├── tommath_rational.html
│ │ │ │ │ │ │ └── tommath_rational0.html
│ │ │ │ │ │ ├── rational.html
│ │ │ │ │ │ ├── rounding.html
│ │ │ │ │ │ ├── serial.html
│ │ │ │ │ │ └── variable.html
│ │ │ │ │ └── tut.html
│ │ │ │ ├── index.html
│ │ │ │ └── multiprecision.css
│ │ │ ├── html4_symbols.qbk
│ │ │ ├── index.idx
│ │ │ ├── introduction.qbk
│ │ │ ├── multiprecision.css
│ │ │ ├── multiprecision.qbk
│ │ │ ├── numeric_limits_32_tables.qbk
│ │ │ ├── numeric_limits_qbk.cpp
│ │ │ ├── performance.qbk
│ │ │ ├── performance_float.qbk
│ │ │ ├── performance_integer.qbk
│ │ │ ├── performance_integer_real_world.qbk
│ │ │ ├── performance_overhead.qbk
│ │ │ ├── performance_rational.qbk
│ │ │ ├── performance_rational_real_world.qbk
│ │ │ ├── performance_real_world.qbk
│ │ │ ├── reference.qbk
│ │ │ ├── reference_backend_requirements.qbk
│ │ │ ├── reference_cpp_bin_float.qbk
│ │ │ ├── reference_cpp_dec_float.qbk
│ │ │ ├── reference_cpp_int.qbk
│ │ │ ├── reference_gmp_float.qbk
│ │ │ ├── reference_gmp_int.qbk
│ │ │ ├── reference_header_structure.qbk
│ │ │ ├── reference_internal_support.qbk
│ │ │ ├── reference_mpfr_float.qbk
│ │ │ ├── reference_number.qbk
│ │ │ ├── reference_tom_int.qbk
│ │ │ ├── tutorial.qbk
│ │ │ ├── tutorial_boost_rational.qbk
│ │ │ ├── tutorial_complex.qbk
│ │ │ ├── tutorial_complex_adaptor.qbk
│ │ │ ├── tutorial_constexpr.qbk
│ │ │ ├── tutorial_conversions.qbk
│ │ │ ├── tutorial_cpp_bin_float.qbk
│ │ │ ├── tutorial_cpp_complex.qbk
│ │ │ ├── tutorial_cpp_dec_float.qbk
│ │ │ ├── tutorial_cpp_int.qbk
│ │ │ ├── tutorial_cpp_rational.qbk
│ │ │ ├── tutorial_debug_adaptor.qbk
│ │ │ ├── tutorial_eigen.qbk
│ │ │ ├── tutorial_float128.qbk
│ │ │ ├── tutorial_float128_complex.qbk
│ │ │ ├── tutorial_float_builtin_ctor.qbk
│ │ │ ├── tutorial_float_eg.qbk
│ │ │ ├── tutorial_floats.qbk
│ │ │ ├── tutorial_gmp_float.qbk
│ │ │ ├── tutorial_gmp_int.qbk
│ │ │ ├── tutorial_gmp_rational.qbk
│ │ │ ├── tutorial_hash.qbk
│ │ │ ├── tutorial_import_export.qbk
│ │ │ ├── tutorial_integer.qbk
│ │ │ ├── tutorial_integer_examples.qbk
│ │ │ ├── tutorial_integer_ops.qbk
│ │ │ ├── tutorial_interval_mpfi.qbk
│ │ │ ├── tutorial_io.qbk
│ │ │ ├── tutorial_logged_adaptor.qbk
│ │ │ ├── tutorial_misc_backends.qbk
│ │ │ ├── tutorial_mixed_precision.qbk
│ │ │ ├── tutorial_mpc_complex.qbk
│ │ │ ├── tutorial_mpfr_float.qbk
│ │ │ ├── tutorial_new_backend.qbk
│ │ │ ├── tutorial_numeric_limits.qbk
│ │ │ ├── tutorial_primality.qbk
│ │ │ ├── tutorial_random.qbk
│ │ │ ├── tutorial_rational.qbk
│ │ │ ├── tutorial_rational_adaptor.qbk
│ │ │ ├── tutorial_rounding.qbk
│ │ │ ├── tutorial_serialization.qbk
│ │ │ ├── tutorial_tommath.qbk
│ │ │ ├── tutorial_tommath_rational.qbk
│ │ │ ├── tutorial_variable_precision.qbk
│ │ │ └── tutorial_visualizers.qbk
│ │ ├── example/
│ │ │ ├── Jamfile.v2
│ │ │ ├── big_seventh.cpp
│ │ │ ├── complex128_examples.cpp
│ │ │ ├── constexpr_float_arithmetic_examples.cpp
│ │ │ ├── cpp_bin_float_import_export.cpp
│ │ │ ├── cpp_bin_float_snips.cpp
│ │ │ ├── cpp_complex_examples.cpp
│ │ │ ├── cpp_dec_float_snips.cpp
│ │ │ ├── cpp_int_import_export.cpp
│ │ │ ├── cpp_int_mul_timing.cpp
│ │ │ ├── cpp_int_snips.cpp
│ │ │ ├── debug_adaptor_snips.cpp
│ │ │ ├── eigen_example.cpp
│ │ │ ├── exercise_threading_log_agm.cpp
│ │ │ ├── float128_snips.cpp
│ │ │ ├── floating_point_examples.cpp
│ │ │ ├── gauss_laguerre_quadrature.cpp
│ │ │ ├── gmp_snips.cpp
│ │ │ ├── hashing_examples.cpp
│ │ │ ├── hypergeometric_luke_algorithms.cpp
│ │ │ ├── integer_examples.cpp
│ │ │ ├── logged_adaptor.cpp
│ │ │ ├── mixed_integer_arithmetic.cpp
│ │ │ ├── mpc_examples.cpp
│ │ │ ├── mpfi_snips.cpp
│ │ │ ├── mpfr_precision.cpp
│ │ │ ├── mpfr_snips.cpp
│ │ │ ├── numeric_limits_snips.cpp
│ │ │ ├── random_snips.cpp
│ │ │ ├── safe_prime.cpp
│ │ │ ├── scoped_precision_example.cpp
│ │ │ ├── standalone_bernoulli_tgamma.cpp
│ │ │ └── tommath_snips.cpp
│ │ ├── include/
│ │ │ └── boost/
│ │ │ ├── config/
│ │ │ │ ├── abi/
│ │ │ │ │ ├── borland_prefix.hpp
│ │ │ │ │ ├── borland_suffix.hpp
│ │ │ │ │ ├── msvc_prefix.hpp
│ │ │ │ │ └── msvc_suffix.hpp
│ │ │ │ ├── abi_prefix.hpp
│ │ │ │ ├── abi_suffix.hpp
│ │ │ │ ├── assert_cxx03.hpp
│ │ │ │ ├── assert_cxx11.hpp
│ │ │ │ ├── assert_cxx14.hpp
│ │ │ │ ├── assert_cxx17.hpp
│ │ │ │ ├── assert_cxx20.hpp
│ │ │ │ ├── assert_cxx98.hpp
│ │ │ │ ├── auto_link.hpp
│ │ │ │ ├── compiler/
│ │ │ │ │ ├── borland.hpp
│ │ │ │ │ ├── clang.hpp
│ │ │ │ │ ├── clang_version.hpp
│ │ │ │ │ ├── codegear.hpp
│ │ │ │ │ ├── comeau.hpp
│ │ │ │ │ ├── common_edg.hpp
│ │ │ │ │ ├── compaq_cxx.hpp
│ │ │ │ │ ├── cray.hpp
│ │ │ │ │ ├── diab.hpp
│ │ │ │ │ ├── digitalmars.hpp
│ │ │ │ │ ├── gcc.hpp
│ │ │ │ │ ├── gcc_xml.hpp
│ │ │ │ │ ├── greenhills.hpp
│ │ │ │ │ ├── hp_acc.hpp
│ │ │ │ │ ├── intel.hpp
│ │ │ │ │ ├── kai.hpp
│ │ │ │ │ ├── metrowerks.hpp
│ │ │ │ │ ├── mpw.hpp
│ │ │ │ │ ├── nvcc.hpp
│ │ │ │ │ ├── pathscale.hpp
│ │ │ │ │ ├── pgi.hpp
│ │ │ │ │ ├── sgi_mipspro.hpp
│ │ │ │ │ ├── sunpro_cc.hpp
│ │ │ │ │ ├── vacpp.hpp
│ │ │ │ │ ├── visualc.hpp
│ │ │ │ │ ├── xlcpp.hpp
│ │ │ │ │ └── xlcpp_zos.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── cxx_composite.hpp
│ │ │ │ │ ├── posix_features.hpp
│ │ │ │ │ ├── select_compiler_config.hpp
│ │ │ │ │ ├── select_platform_config.hpp
│ │ │ │ │ ├── select_stdlib_config.hpp
│ │ │ │ │ └── suffix.hpp
│ │ │ │ ├── header_deprecated.hpp
│ │ │ │ ├── helper_macros.hpp
│ │ │ │ ├── no_tr1/
│ │ │ │ │ ├── cmath.hpp
│ │ │ │ │ ├── complex.hpp
│ │ │ │ │ ├── functional.hpp
│ │ │ │ │ ├── memory.hpp
│ │ │ │ │ └── utility.hpp
│ │ │ │ ├── platform/
│ │ │ │ │ ├── aix.hpp
│ │ │ │ │ ├── amigaos.hpp
│ │ │ │ │ ├── beos.hpp
│ │ │ │ │ ├── bsd.hpp
│ │ │ │ │ ├── cloudabi.hpp
│ │ │ │ │ ├── cray.hpp
│ │ │ │ │ ├── cygwin.hpp
│ │ │ │ │ ├── haiku.hpp
│ │ │ │ │ ├── hpux.hpp
│ │ │ │ │ ├── irix.hpp
│ │ │ │ │ ├── linux.hpp
│ │ │ │ │ ├── macos.hpp
│ │ │ │ │ ├── qnxnto.hpp
│ │ │ │ │ ├── solaris.hpp
│ │ │ │ │ ├── symbian.hpp
│ │ │ │ │ ├── vms.hpp
│ │ │ │ │ ├── vxworks.hpp
│ │ │ │ │ ├── wasm.hpp
│ │ │ │ │ ├── win32.hpp
│ │ │ │ │ └── zos.hpp
│ │ │ │ ├── pragma_message.hpp
│ │ │ │ ├── requires_threads.hpp
│ │ │ │ ├── stdlib/
│ │ │ │ │ ├── dinkumware.hpp
│ │ │ │ │ ├── libcomo.hpp
│ │ │ │ │ ├── libcpp.hpp
│ │ │ │ │ ├── libstdcpp3.hpp
│ │ │ │ │ ├── modena.hpp
│ │ │ │ │ ├── msl.hpp
│ │ │ │ │ ├── roguewave.hpp
│ │ │ │ │ ├── sgi.hpp
│ │ │ │ │ ├── stlport.hpp
│ │ │ │ │ ├── vacpp.hpp
│ │ │ │ │ └── xlcpp_zos.hpp
│ │ │ │ ├── user.hpp
│ │ │ │ ├── warning_disable.hpp
│ │ │ │ └── workaround.hpp
│ │ │ ├── config.hpp
│ │ │ ├── cstdint.hpp
│ │ │ ├── cxx11_char_types.hpp
│ │ │ ├── detail/
│ │ │ │ └── workaround.hpp
│ │ │ ├── limits.hpp
│ │ │ ├── multiprecision/
│ │ │ │ ├── complex128.hpp
│ │ │ │ ├── complex_adaptor.hpp
│ │ │ │ ├── concepts/
│ │ │ │ │ └── mp_number_archetypes.hpp
│ │ │ │ ├── cpp_bin_float/
│ │ │ │ │ ├── io.hpp
│ │ │ │ │ └── transcendental.hpp
│ │ │ │ ├── cpp_bin_float.hpp
│ │ │ │ ├── cpp_complex.hpp
│ │ │ │ ├── cpp_dec_float.hpp
│ │ │ │ ├── cpp_int/
│ │ │ │ │ ├── add.hpp
│ │ │ │ │ ├── add_unsigned.hpp
│ │ │ │ │ ├── bitwise.hpp
│ │ │ │ │ ├── checked.hpp
│ │ │ │ │ ├── comparison.hpp
│ │ │ │ │ ├── cpp_int_config.hpp
│ │ │ │ │ ├── divide.hpp
│ │ │ │ │ ├── import_export.hpp
│ │ │ │ │ ├── intel_intrinsics.hpp
│ │ │ │ │ ├── limits.hpp
│ │ │ │ │ ├── literals.hpp
│ │ │ │ │ ├── misc.hpp
│ │ │ │ │ ├── multiply.hpp
│ │ │ │ │ ├── serialize.hpp
│ │ │ │ │ └── value_pack.hpp
│ │ │ │ ├── cpp_int.hpp
│ │ │ │ ├── debug_adaptor.hpp
│ │ │ │ ├── detail/
│ │ │ │ │ ├── assert.hpp
│ │ │ │ │ ├── atomic.hpp
│ │ │ │ │ ├── bitscan.hpp
│ │ │ │ │ ├── check_cpp11_config.hpp
│ │ │ │ │ ├── constexpr.hpp
│ │ │ │ │ ├── default_ops.hpp
│ │ │ │ │ ├── digits.hpp
│ │ │ │ │ ├── dynamic_array.hpp
│ │ │ │ │ ├── empty_value.hpp
│ │ │ │ │ ├── endian.hpp
│ │ │ │ │ ├── et_ops.hpp
│ │ │ │ │ ├── float128_functions.hpp
│ │ │ │ │ ├── float_string_cvt.hpp
│ │ │ │ │ ├── fpclassify.hpp
│ │ │ │ │ ├── functions/
│ │ │ │ │ │ ├── constants.hpp
│ │ │ │ │ │ ├── pow.hpp
│ │ │ │ │ │ ├── trig.hpp
│ │ │ │ │ │ └── trunc.hpp
│ │ │ │ │ ├── generic_interconvert.hpp
│ │ │ │ │ ├── hash.hpp
│ │ │ │ │ ├── integer_ops.hpp
│ │ │ │ │ ├── itos.hpp
│ │ │ │ │ ├── min_max.hpp
│ │ │ │ │ ├── no_et_ops.hpp
│ │ │ │ │ ├── no_exceptions_support.hpp
│ │ │ │ │ ├── number_base.hpp
│ │ │ │ │ ├── number_compare.hpp
│ │ │ │ │ ├── precision.hpp
│ │ │ │ │ ├── rebind.hpp
│ │ │ │ │ ├── standalone_config.hpp
│ │ │ │ │ ├── static_array.hpp
│ │ │ │ │ ├── tables.hpp
│ │ │ │ │ ├── ublas_interop.hpp
│ │ │ │ │ ├── uniform_int_distribution.hpp
│ │ │ │ │ └── utype_helper.hpp
│ │ │ │ ├── eigen.hpp
│ │ │ │ ├── float128.hpp
│ │ │ │ ├── gmp.hpp
│ │ │ │ ├── integer.hpp
│ │ │ │ ├── logged_adaptor.hpp
│ │ │ │ ├── miller_rabin.hpp
│ │ │ │ ├── mpc.hpp
│ │ │ │ ├── mpfi.hpp
│ │ │ │ ├── mpfr.hpp
│ │ │ │ ├── number.hpp
│ │ │ │ ├── random.hpp
│ │ │ │ ├── rational_adaptor.hpp
│ │ │ │ ├── tommath.hpp
│ │ │ │ └── traits/
│ │ │ │ ├── explicit_conversion.hpp
│ │ │ │ ├── extract_exponent_type.hpp
│ │ │ │ ├── is_backend.hpp
│ │ │ │ ├── is_byte_container.hpp
│ │ │ │ ├── is_complex.hpp
│ │ │ │ ├── is_convertible_arithmetic.hpp
│ │ │ │ ├── is_restricted_conversion.hpp
│ │ │ │ ├── is_variable_precision.hpp
│ │ │ │ ├── max_digits10.hpp
│ │ │ │ ├── std_integer_traits.hpp
│ │ │ │ └── transcendental_reduction_type.hpp
│ │ │ └── version.hpp
│ │ ├── index.html
│ │ ├── meta/
│ │ │ └── libraries.json
│ │ ├── performance/
│ │ │ ├── Jamfile.v2
│ │ │ ├── arithmetic_backend.hpp
│ │ │ ├── cpp_bin_float_conversion_performance.cpp
│ │ │ ├── delaunay_test.cpp
│ │ │ ├── delaunay_test.log
│ │ │ ├── gcd_bench.cpp
│ │ │ ├── linpack-benchmark.cpp
│ │ │ ├── miller_rabin_performance.cpp
│ │ │ ├── miller_rabin_performance.hpp
│ │ │ ├── miller_rabin_performance.log
│ │ │ ├── miller_rabin_performance_files/
│ │ │ │ ├── test01.cpp
│ │ │ │ ├── test02.cpp
│ │ │ │ ├── test03.cpp
│ │ │ │ ├── test04.cpp
│ │ │ │ ├── test05.cpp
│ │ │ │ ├── test06.cpp
│ │ │ │ ├── test07.cpp
│ │ │ │ ├── test08.cpp
│ │ │ │ ├── test09.cpp
│ │ │ │ ├── test10.cpp
│ │ │ │ ├── test11.cpp
│ │ │ │ └── test12.cpp
│ │ │ ├── mixed_equivalent_types_bench.cpp
│ │ │ ├── performance_test-gcc-linux.log
│ │ │ ├── performance_test-intel-linux.log
│ │ │ ├── performance_test-msvc-10.log
│ │ │ ├── performance_test.cpp
│ │ │ ├── performance_test.hpp
│ │ │ ├── performance_test.log
│ │ │ ├── performance_test_files/
│ │ │ │ ├── test01.cpp
│ │ │ │ ├── test02.cpp
│ │ │ │ ├── test03.cpp
│ │ │ │ ├── test04.cpp
│ │ │ │ ├── test05.cpp
│ │ │ │ ├── test06.cpp
│ │ │ │ ├── test07.cpp
│ │ │ │ ├── test08.cpp
│ │ │ │ ├── test09.cpp
│ │ │ │ ├── test10.cpp
│ │ │ │ ├── test11.cpp
│ │ │ │ ├── test12.cpp
│ │ │ │ ├── test13.cpp
│ │ │ │ ├── test14.cpp
│ │ │ │ ├── test15.cpp
│ │ │ │ ├── test16.cpp
│ │ │ │ ├── test17.cpp
│ │ │ │ ├── test18.cpp
│ │ │ │ ├── test19.cpp
│ │ │ │ ├── test20.cpp
│ │ │ │ ├── test21.cpp
│ │ │ │ ├── test22.cpp
│ │ │ │ ├── test23.cpp
│ │ │ │ ├── test24.cpp
│ │ │ │ ├── test25.cpp
│ │ │ │ ├── test26.cpp
│ │ │ │ ├── test27.cpp
│ │ │ │ ├── test28.cpp
│ │ │ │ ├── test29.cpp
│ │ │ │ ├── test30.cpp
│ │ │ │ ├── test31.cpp
│ │ │ │ ├── test32.cpp
│ │ │ │ ├── test33.cpp
│ │ │ │ ├── test34.cpp
│ │ │ │ ├── test35.cpp
│ │ │ │ ├── test36.cpp
│ │ │ │ ├── test37.cpp
│ │ │ │ ├── test38.cpp
│ │ │ │ ├── test39.cpp
│ │ │ │ ├── test40.cpp
│ │ │ │ ├── test41.cpp
│ │ │ │ ├── test42.cpp
│ │ │ │ ├── test43.cpp
│ │ │ │ ├── test44.cpp
│ │ │ │ ├── test45.cpp
│ │ │ │ ├── test46.cpp
│ │ │ │ ├── test47.cpp
│ │ │ │ ├── test48.cpp
│ │ │ │ ├── test49.cpp
│ │ │ │ ├── test50.cpp
│ │ │ │ └── test51.cpp
│ │ │ ├── rational_bernoulli_allocations.cpp
│ │ │ ├── rational_bernoulli_allocations.log
│ │ │ ├── rational_bernoulli_bench.cpp
│ │ │ ├── rational_bernoulli_bench.log
│ │ │ ├── rational_determinant_bench.cpp
│ │ │ ├── rational_determinant_bench.log
│ │ │ ├── rational_zeta18_bench.cpp
│ │ │ ├── sf_performance-msvc-10.log
│ │ │ ├── sf_performance.cpp
│ │ │ ├── sf_performance.hpp
│ │ │ ├── sf_performance.log
│ │ │ ├── sf_performance_basic.cpp
│ │ │ ├── sf_performance_bessel.cpp
│ │ │ ├── sf_performance_files/
│ │ │ │ ├── sf_performance_basic_1.cpp
│ │ │ │ ├── sf_performance_basic_2.cpp
│ │ │ │ ├── sf_performance_basic_3.cpp
│ │ │ │ ├── sf_performance_basic_4.cpp
│ │ │ │ ├── sf_performance_basic_5.cpp
│ │ │ │ ├── sf_performance_basic_6.cpp
│ │ │ │ ├── sf_performance_basic_7.cpp
│ │ │ │ ├── sf_performance_basic_8.cpp
│ │ │ │ ├── sf_performance_basic_9.cpp
│ │ │ │ ├── sf_performance_bessel_01.cpp
│ │ │ │ ├── sf_performance_bessel_02.cpp
│ │ │ │ ├── sf_performance_bessel_03.cpp
│ │ │ │ ├── sf_performance_bessel_04.cpp
│ │ │ │ ├── sf_performance_bessel_05.cpp
│ │ │ │ ├── sf_performance_bessel_06.cpp
│ │ │ │ ├── sf_performance_bessel_07.cpp
│ │ │ │ ├── sf_performance_bessel_08.cpp
│ │ │ │ ├── sf_performance_bessel_09.cpp
│ │ │ │ ├── sf_performance_bessel_10.cpp
│ │ │ │ ├── sf_performance_bessel_11.cpp
│ │ │ │ ├── sf_performance_bessel_12.cpp
│ │ │ │ ├── sf_performance_bessel_13.cpp
│ │ │ │ ├── sf_performance_bessel_14.cpp
│ │ │ │ ├── sf_performance_bessel_15.cpp
│ │ │ │ ├── sf_performance_bessel_16.cpp
│ │ │ │ ├── sf_performance_bessel_17.cpp
│ │ │ │ ├── sf_performance_bessel_18.cpp
│ │ │ │ ├── sf_performance_bessel_19.cpp
│ │ │ │ ├── sf_performance_nct_01.cpp
│ │ │ │ ├── sf_performance_nct_02.cpp
│ │ │ │ ├── sf_performance_nct_03.cpp
│ │ │ │ ├── sf_performance_nct_04.cpp
│ │ │ │ ├── sf_performance_nct_05.cpp
│ │ │ │ ├── sf_performance_nct_06.cpp
│ │ │ │ ├── sf_performance_nct_07.cpp
│ │ │ │ ├── sf_performance_nct_08.cpp
│ │ │ │ ├── sf_performance_nct_09.cpp
│ │ │ │ ├── sf_performance_nct_10.cpp
│ │ │ │ ├── sf_performance_nct_11.cpp
│ │ │ │ ├── sf_performance_nct_12.cpp
│ │ │ │ ├── sf_performance_nct_13.cpp
│ │ │ │ ├── sf_performance_nct_14.cpp
│ │ │ │ ├── sf_performance_nct_15.cpp
│ │ │ │ ├── sf_performance_nct_16.cpp
│ │ │ │ ├── sf_performance_nct_17.cpp
│ │ │ │ ├── sf_performance_nct_18.cpp
│ │ │ │ ├── sf_performance_nct_19.cpp
│ │ │ │ ├── sf_performance_nct_20.cpp
│ │ │ │ ├── sf_performance_poly_01.cpp
│ │ │ │ ├── sf_performance_poly_02.cpp
│ │ │ │ ├── sf_performance_poly_03.cpp
│ │ │ │ ├── sf_performance_poly_04.cpp
│ │ │ │ ├── sf_performance_poly_05.cpp
│ │ │ │ ├── sf_performance_poly_06.cpp
│ │ │ │ ├── sf_performance_poly_07.cpp
│ │ │ │ ├── sf_performance_poly_08.cpp
│ │ │ │ ├── sf_performance_poly_09.cpp
│ │ │ │ ├── sf_performance_poly_10.cpp
│ │ │ │ ├── sf_performance_poly_11.cpp
│ │ │ │ ├── sf_performance_poly_12.cpp
│ │ │ │ ├── sf_performance_poly_13.cpp
│ │ │ │ ├── sf_performance_poly_14.cpp
│ │ │ │ ├── sf_performance_poly_15.cpp
│ │ │ │ ├── sf_performance_poly_16.cpp
│ │ │ │ ├── sf_performance_poly_17.cpp
│ │ │ │ └── sf_performance_poly_18.cpp
│ │ │ ├── sf_performance_nct.cpp
│ │ │ ├── sf_performance_poly.cpp
│ │ │ ├── sqrt_bench.cpp
│ │ │ ├── veronoi_performance.log
│ │ │ └── voronoi_performance.cpp
│ │ ├── plots/
│ │ │ ├── cpp_bin_float_acos_errors.cpp
│ │ │ ├── cpp_bin_float_asin_errors.cpp
│ │ │ ├── cpp_bin_float_atan_errors.cpp
│ │ │ ├── cpp_bin_float_cos_errors.cpp
│ │ │ ├── cpp_bin_float_erf_errors.cpp
│ │ │ ├── cpp_bin_float_erfc_errors.cpp
│ │ │ ├── cpp_bin_float_exp_errors.cpp
│ │ │ ├── cpp_bin_float_log_errors.cpp
│ │ │ ├── cpp_bin_float_sin_errors.cpp
│ │ │ ├── cpp_bin_float_tan_errors.cpp
│ │ │ └── cpp_bin_float_tgamma_errors.cpp
│ │ ├── test/
│ │ │ ├── Jamfile.v2
│ │ │ ├── bug11922.cpp
│ │ │ ├── bug12039.cpp
│ │ │ ├── compile_fail/
│ │ │ │ ├── conv_fail_01.cpp
│ │ │ │ ├── conv_fail_02.cpp
│ │ │ │ ├── conv_fail_03.cpp
│ │ │ │ ├── conv_fail_04.cpp
│ │ │ │ ├── conv_fail_05.cpp
│ │ │ │ ├── conv_fail_06.cpp
│ │ │ │ ├── conv_fail_07.cpp
│ │ │ │ ├── conv_fail_08.cpp
│ │ │ │ ├── conv_fail_09.cpp
│ │ │ │ ├── conv_fail_10.cpp
│ │ │ │ ├── conv_fail_11.cpp
│ │ │ │ ├── conv_fail_12.cpp
│ │ │ │ ├── conv_fail_13.cpp
│ │ │ │ ├── conv_fail_14.cpp
│ │ │ │ ├── conv_fail_15.cpp
│ │ │ │ ├── conv_fail_16.cpp
│ │ │ │ ├── conv_fail_18.cpp
│ │ │ │ ├── conv_fail_20.cpp
│ │ │ │ ├── conv_fail_21.cpp
│ │ │ │ ├── conv_fail_22.cpp
│ │ │ │ ├── conv_fail_23.cpp
│ │ │ │ ├── conv_fail_24.cpp
│ │ │ │ ├── conv_fail_25.cpp
│ │ │ │ ├── conv_fail_26.cpp
│ │ │ │ ├── conv_fail_27.cpp
│ │ │ │ ├── conv_fail_28.cpp
│ │ │ │ ├── conv_fail_29.cpp
│ │ │ │ ├── conv_fail_30.cpp
│ │ │ │ ├── conv_fail_31.cpp
│ │ │ │ ├── conv_fail_32.cpp
│ │ │ │ ├── conv_fail_33.cpp
│ │ │ │ ├── conv_fail_34.cpp
│ │ │ │ ├── conv_fail_35.cpp
│ │ │ │ ├── conv_fail_36.cpp
│ │ │ │ ├── conv_fail_37.cpp
│ │ │ │ ├── conv_fail_38.cpp
│ │ │ │ ├── conv_fail_39.cpp
│ │ │ │ ├── conv_fail_40.cpp
│ │ │ │ ├── conv_fail_41.cpp
│ │ │ │ ├── conv_fail_42.cpp
│ │ │ │ ├── conv_fail_43.cpp
│ │ │ │ ├── conv_fail_44.cpp
│ │ │ │ ├── conv_fail_45.cpp
│ │ │ │ ├── conv_fail_46.cpp
│ │ │ │ ├── conv_fail_47.cpp
│ │ │ │ ├── conv_fail_48.cpp
│ │ │ │ ├── conv_fail_49.cpp
│ │ │ │ ├── conv_fail_50.cpp
│ │ │ │ ├── conv_fail_51.cpp
│ │ │ │ ├── conv_fail_52.cpp
│ │ │ │ ├── conv_fail_53.cpp
│ │ │ │ ├── conv_fail_54.cpp
│ │ │ │ ├── conv_fail_55.cpp
│ │ │ │ ├── conv_fail_56.cpp
│ │ │ │ ├── conv_fail_57.cpp
│ │ │ │ ├── conv_fail_58.cpp
│ │ │ │ ├── conv_fail_59.cpp
│ │ │ │ ├── cpp_int_complement.cpp
│ │ │ │ ├── cpp_int_negate_1.cpp
│ │ │ │ ├── cpp_int_negate_2.cpp
│ │ │ │ ├── operator_fail_01.cpp
│ │ │ │ ├── operator_fail_02.cpp
│ │ │ │ ├── operator_fail_03.cpp
│ │ │ │ ├── operator_fail_04.cpp
│ │ │ │ ├── operator_fail_05.cpp
│ │ │ │ ├── operator_fail_06.cpp
│ │ │ │ ├── operator_fail_07.cpp
│ │ │ │ ├── operator_fail_08.cpp
│ │ │ │ ├── operator_fail_09.cpp
│ │ │ │ ├── operator_fail_10.cpp
│ │ │ │ ├── operator_fail_11.cpp
│ │ │ │ ├── operator_fail_12.cpp
│ │ │ │ ├── operator_fail_13.cpp
│ │ │ │ ├── operator_fail_14.cpp
│ │ │ │ ├── operator_fail_15.cpp
│ │ │ │ ├── operator_fail_16.cpp
│ │ │ │ ├── operator_fail_17.cpp
│ │ │ │ └── operator_fail_18.cpp
│ │ │ ├── concepts/
│ │ │ │ ├── number_concept_check.cpp
│ │ │ │ ├── sf_concept_check_basic.cpp
│ │ │ │ ├── sf_concept_check_bessel.cpp
│ │ │ │ ├── sf_concept_check_beta.cpp
│ │ │ │ ├── sf_concept_check_beta_2.cpp
│ │ │ │ ├── sf_concept_check_beta_3.cpp
│ │ │ │ ├── sf_concept_check_elliptic.cpp
│ │ │ │ ├── sf_concept_check_gamma.cpp
│ │ │ │ └── sf_concept_check_poly.cpp
│ │ │ ├── constexpr_arithmetric_test.hpp
│ │ │ ├── constexpr_test_arithmetic_backend.cpp
│ │ │ ├── constexpr_test_cpp_int.cpp
│ │ │ ├── constexpr_test_cpp_int_2.cpp
│ │ │ ├── constexpr_test_cpp_int_3.cpp
│ │ │ ├── constexpr_test_cpp_int_4.cpp
│ │ │ ├── constexpr_test_cpp_int_5.cpp
│ │ │ ├── constexpr_test_cpp_int_6.cpp
│ │ │ ├── constexpr_test_cpp_int_7.cpp
│ │ │ ├── constexpr_test_float128.cpp
│ │ │ ├── eigen.hpp
│ │ │ ├── git_issue_167.cpp
│ │ │ ├── git_issue_175.cpp
│ │ │ ├── git_issue_248.cpp
│ │ │ ├── git_issue_265.cpp
│ │ │ ├── git_issue_277.cpp
│ │ │ ├── git_issue_30.cpp
│ │ │ ├── git_issue_313.cpp
│ │ │ ├── git_issue_370.cpp
│ │ │ ├── git_issue_393.cpp
│ │ │ ├── git_issue_426.cpp
│ │ │ ├── git_issue_464.cpp
│ │ │ ├── git_issue_488.cpp
│ │ │ ├── git_issue_98.cpp
│ │ │ ├── include_test/
│ │ │ │ ├── cpp_bin_float_include_test.cpp
│ │ │ │ ├── cpp_dec_float_include_test.cpp
│ │ │ │ ├── cpp_int_include_test.cpp
│ │ │ │ ├── gmp_include_test.cpp
│ │ │ │ ├── mpfr_include_test.cpp
│ │ │ │ └── tommath_include_test.cpp
│ │ │ ├── issue_13148.cpp
│ │ │ ├── issue_13301.cpp
│ │ │ ├── math/
│ │ │ │ ├── high_prec/
│ │ │ │ │ ├── gamma.ipp
│ │ │ │ │ ├── gamma_0.ipp
│ │ │ │ │ ├── gamma_1_2.ipp
│ │ │ │ │ ├── gamma_neg.ipp
│ │ │ │ │ ├── readme.txt
│ │ │ │ │ ├── test_gamma.cpp
│ │ │ │ │ └── test_gamma.hpp
│ │ │ │ ├── instances/
│ │ │ │ │ ├── Jamfile.v2
│ │ │ │ │ └── instances.cpp
│ │ │ │ ├── log1p_expm1_test.cpp
│ │ │ │ ├── powm1_sqrtp1m1_test.cpp
│ │ │ │ ├── readme.txt
│ │ │ │ ├── setup.hpp
│ │ │ │ ├── table_type.hpp
│ │ │ │ ├── test_bessel_i.cpp
│ │ │ │ ├── test_bessel_j.cpp
│ │ │ │ ├── test_bessel_k.cpp
│ │ │ │ ├── test_bessel_y.cpp
│ │ │ │ ├── test_beta.cpp
│ │ │ │ ├── test_binomial_coeff.cpp
│ │ │ │ ├── test_carlson_1.cpp
│ │ │ │ ├── test_carlson_2.cpp
│ │ │ │ ├── test_carlson_3.cpp
│ │ │ │ ├── test_carlson_4.cpp
│ │ │ │ ├── test_cbrt.cpp
│ │ │ │ ├── test_digamma.cpp
│ │ │ │ ├── test_ellint_1.cpp
│ │ │ │ ├── test_ellint_2.cpp
│ │ │ │ ├── test_ellint_3.cpp
│ │ │ │ ├── test_erf.cpp
│ │ │ │ ├── test_expint.cpp
│ │ │ │ ├── test_gamma.cpp
│ │ │ │ ├── test_hermite.cpp
│ │ │ │ ├── test_ibeta.cpp
│ │ │ │ ├── test_ibeta_2.cpp
│ │ │ │ ├── test_ibeta_3.cpp
│ │ │ │ ├── test_ibeta_4.cpp
│ │ │ │ ├── test_ibeta_inv_1.cpp
│ │ │ │ ├── test_ibeta_inv_ab_4.cpp
│ │ │ │ ├── test_igamma.cpp
│ │ │ │ ├── test_igamma_inv.cpp
│ │ │ │ ├── test_igamma_inva.cpp
│ │ │ │ ├── test_laguerre.cpp
│ │ │ │ ├── test_legendre.cpp
│ │ │ │ ├── test_tgamma_ratio.cpp
│ │ │ │ └── test_zeta.cpp
│ │ │ ├── no_eh_test_support.cpp
│ │ │ ├── serial_txts/
│ │ │ │ ├── boost-no-inspect
│ │ │ │ ├── cpp_int1024_serial32.txt
│ │ │ │ ├── cpp_int1024_serial64.txt
│ │ │ │ ├── cpp_int128_serial32.txt
│ │ │ │ ├── cpp_int128_serial64.txt
│ │ │ │ ├── cpp_int64_serial32.txt
│ │ │ │ └── cpp_int64_serial64.txt
│ │ │ ├── sincos.ipp
│ │ │ ├── skeleton_backend.hpp
│ │ │ ├── standalone_constexpr_test_cpp_int.cpp
│ │ │ ├── standalone_constexpr_test_float128.cpp
│ │ │ ├── standalone_test_arithmetic_complex128.cpp
│ │ │ ├── standalone_test_arithmetic_cpp_bin_float.cpp
│ │ │ ├── standalone_test_arithmetic_cpp_dec_float.cpp
│ │ │ ├── standalone_test_arithmetic_cpp_int.cpp
│ │ │ ├── standalone_test_arithmetic_cpp_rational.cpp
│ │ │ ├── standalone_test_arithmetic_float_128.cpp
│ │ │ ├── standalone_test_arithmetic_gmp.cpp
│ │ │ ├── standalone_test_arithmetic_int512.cpp
│ │ │ ├── standalone_test_arithmetic_mpf_logged_adptr.cpp
│ │ │ ├── standalone_test_arithmetic_mpz_rat.cpp
│ │ │ ├── standalone_test_arithmetic_tommath.cpp
│ │ │ ├── standalone_test_convert_from_tom_int.cpp
│ │ │ ├── standalone_test_miller_rabin.cpp
│ │ │ ├── string_data.ipp
│ │ │ ├── test.hpp
│ │ │ ├── test_acos.cpp
│ │ │ ├── test_adapt_serial.cpp
│ │ │ ├── test_arithmetic.hpp
│ │ │ ├── test_arithmetic_ab_1.cpp
│ │ │ ├── test_arithmetic_ab_2.cpp
│ │ │ ├── test_arithmetic_ab_3.cpp
│ │ │ ├── test_arithmetic_backend_concept.cpp
│ │ │ ├── test_arithmetic_complex128.cpp
│ │ │ ├── test_arithmetic_complex_adaptor.cpp
│ │ │ ├── test_arithmetic_complex_adaptor_2.cpp
│ │ │ ├── test_arithmetic_cpp_bin_float_1.cpp
│ │ │ ├── test_arithmetic_cpp_bin_float_2.cpp
│ │ │ ├── test_arithmetic_cpp_bin_float_2m.cpp
│ │ │ ├── test_arithmetic_cpp_bin_float_3.cpp
│ │ │ ├── test_arithmetic_cpp_bin_float_4.cpp
│ │ │ ├── test_arithmetic_cpp_bin_float_5.cpp
│ │ │ ├── test_arithmetic_cpp_complex_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_cpp_complex_logged_adptr.cpp
│ │ │ ├── test_arithmetic_cpp_dec_float_1.cpp
│ │ │ ├── test_arithmetic_cpp_dec_float_2.cpp
│ │ │ ├── test_arithmetic_cpp_dec_float_3.cpp
│ │ │ ├── test_arithmetic_cpp_dec_float_3m.cpp
│ │ │ ├── test_arithmetic_cpp_int_1.cpp
│ │ │ ├── test_arithmetic_cpp_int_10.cpp
│ │ │ ├── test_arithmetic_cpp_int_11.cpp
│ │ │ ├── test_arithmetic_cpp_int_12.cpp
│ │ │ ├── test_arithmetic_cpp_int_13.cpp
│ │ │ ├── test_arithmetic_cpp_int_14.cpp
│ │ │ ├── test_arithmetic_cpp_int_15.cpp
│ │ │ ├── test_arithmetic_cpp_int_16.cpp
│ │ │ ├── test_arithmetic_cpp_int_17.cpp
│ │ │ ├── test_arithmetic_cpp_int_18.cpp
│ │ │ ├── test_arithmetic_cpp_int_19.cpp
│ │ │ ├── test_arithmetic_cpp_int_2.cpp
│ │ │ ├── test_arithmetic_cpp_int_20.cpp
│ │ │ ├── test_arithmetic_cpp_int_21.cpp
│ │ │ ├── test_arithmetic_cpp_int_22.cpp
│ │ │ ├── test_arithmetic_cpp_int_23.cpp
│ │ │ ├── test_arithmetic_cpp_int_3.cpp
│ │ │ ├── test_arithmetic_cpp_int_4.cpp
│ │ │ ├── test_arithmetic_cpp_int_5.cpp
│ │ │ ├── test_arithmetic_cpp_int_6.cpp
│ │ │ ├── test_arithmetic_cpp_int_7.cpp
│ │ │ ├── test_arithmetic_cpp_int_8.cpp
│ │ │ ├── test_arithmetic_cpp_int_9.cpp
│ │ │ ├── test_arithmetic_cpp_int_br.cpp
│ │ │ ├── test_arithmetic_cpp_int_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_cpp_int_logged_adptr.cpp
│ │ │ ├── test_arithmetic_cpp_rat_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_cpp_rat_logged_adptr.cpp
│ │ │ ├── test_arithmetic_dbg_adptr1.cpp
│ │ │ ├── test_arithmetic_dbg_adptr1m.cpp
│ │ │ ├── test_arithmetic_dbg_adptr2.cpp
│ │ │ ├── test_arithmetic_float_128.cpp
│ │ │ ├── test_arithmetic_logged_1.cpp
│ │ │ ├── test_arithmetic_logged_2.cpp
│ │ │ ├── test_arithmetic_mpc.cpp
│ │ │ ├── test_arithmetic_mpc_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_mpc_logged_adptr.cpp
│ │ │ ├── test_arithmetic_mpf.cpp
│ │ │ ├── test_arithmetic_mpf_50.cpp
│ │ │ ├── test_arithmetic_mpf_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_mpf_logged_adptr.cpp
│ │ │ ├── test_arithmetic_mpfi_50.cpp
│ │ │ ├── test_arithmetic_mpfi_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_mpfi_logged_adptr.cpp
│ │ │ ├── test_arithmetic_mpfr.cpp
│ │ │ ├── test_arithmetic_mpfr_50.cpp
│ │ │ ├── test_arithmetic_mpfr_50_mixed.cpp
│ │ │ ├── test_arithmetic_mpfr_50_static.cpp
│ │ │ ├── test_arithmetic_mpfr_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_mpfr_logged_adptr.cpp
│ │ │ ├── test_arithmetic_mpq.cpp
│ │ │ ├── test_arithmetic_mpq_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_mpq_logged_adptr.cpp
│ │ │ ├── test_arithmetic_mpz.cpp
│ │ │ ├── test_arithmetic_mpz_br.cpp
│ │ │ ├── test_arithmetic_mpz_dbg_adptr.cpp
│ │ │ ├── test_arithmetic_mpz_logged_adptr.cpp
│ │ │ ├── test_arithmetic_mpz_rat.cpp
│ │ │ ├── test_arithmetic_skeleton.cpp
│ │ │ ├── test_arithmetic_tommath.cpp
│ │ │ ├── test_arithmetic_tommath_br.cpp
│ │ │ ├── test_arithmetic_tommath_rat.cpp
│ │ │ ├── test_asin.cpp
│ │ │ ├── test_assume_uniform_precision.cpp
│ │ │ ├── test_atan.cpp
│ │ │ ├── test_checked_cpp_int.cpp
│ │ │ ├── test_checked_mixed_cpp_int.cpp
│ │ │ ├── test_complex.cpp
│ │ │ ├── test_complex_signed_zero.cpp
│ │ │ ├── test_constants.cpp
│ │ │ ├── test_constexpr.cpp
│ │ │ ├── test_convert_cpp_int_2_float.cpp
│ │ │ ├── test_convert_from_cpp_bin_float.cpp
│ │ │ ├── test_convert_from_cpp_dec_float.cpp
│ │ │ ├── test_convert_from_cpp_int.cpp
│ │ │ ├── test_convert_from_cpp_rational.cpp
│ │ │ ├── test_convert_from_float128.cpp
│ │ │ ├── test_convert_from_gmp_rational.cpp
│ │ │ ├── test_convert_from_mpf_float.cpp
│ │ │ ├── test_convert_from_mpfi_float.cpp
│ │ │ ├── test_convert_from_mpfr_float.cpp
│ │ │ ├── test_convert_from_mpz_int.cpp
│ │ │ ├── test_convert_from_tom_int.cpp
│ │ │ ├── test_convert_from_tom_rational.cpp
│ │ │ ├── test_cos.cpp
│ │ │ ├── test_cos_near_half_pi.cpp
│ │ │ ├── test_cosh.cpp
│ │ │ ├── test_cpp_bin_float.cpp
│ │ │ ├── test_cpp_bin_float_conv.cpp
│ │ │ ├── test_cpp_bin_float_io.cpp
│ │ │ ├── test_cpp_bin_float_round.cpp
│ │ │ ├── test_cpp_bin_float_serial.cpp
│ │ │ ├── test_cpp_bin_float_tgamma.cpp
│ │ │ ├── test_cpp_dec_float_conv.cpp
│ │ │ ├── test_cpp_dec_float_round.cpp
│ │ │ ├── test_cpp_dec_float_serial.cpp
│ │ │ ├── test_cpp_dec_float_tgamma.cpp
│ │ │ ├── test_cpp_int.cpp
│ │ │ ├── test_cpp_int_conv.cpp
│ │ │ ├── test_cpp_int_deserial.cpp
│ │ │ ├── test_cpp_int_import_export.cpp
│ │ │ ├── test_cpp_int_karatsuba.cpp
│ │ │ ├── test_cpp_int_left_shift.cpp
│ │ │ ├── test_cpp_int_lit.cpp
│ │ │ ├── test_cpp_int_serial.cpp
│ │ │ ├── test_cpp_rat_serial.cpp
│ │ │ ├── test_cpp_rational.cpp
│ │ │ ├── test_eigen_interop.cpp
│ │ │ ├── test_eigen_interop_cpp_bin_float_1.cpp
│ │ │ ├── test_eigen_interop_cpp_bin_float_2.cpp
│ │ │ ├── test_eigen_interop_cpp_bin_float_3.cpp
│ │ │ ├── test_eigen_interop_cpp_dec_float.cpp
│ │ │ ├── test_eigen_interop_cpp_dec_float_2.cpp
│ │ │ ├── test_eigen_interop_cpp_dec_float_3.cpp
│ │ │ ├── test_eigen_interop_cpp_int.cpp
│ │ │ ├── test_eigen_interop_gmp.cpp
│ │ │ ├── test_eigen_interop_gmp_2.cpp
│ │ │ ├── test_eigen_interop_mpc.cpp
│ │ │ ├── test_eigen_interop_mpfr_1.cpp
│ │ │ ├── test_eigen_interop_mpfr_2.cpp
│ │ │ ├── test_eigen_interop_mpfr_3.cpp
│ │ │ ├── test_eigen_interop_mpfr_4.cpp
│ │ │ ├── test_eigen_interop_mpfr_5.cpp
│ │ │ ├── test_eigen_interop_mpfr_6.cpp
│ │ │ ├── test_exp.cpp
│ │ │ ├── test_fixed_int.cpp
│ │ │ ├── test_fixed_zero_precision_io.cpp
│ │ │ ├── test_float128_serial.cpp
│ │ │ ├── test_float_conversions.cpp
│ │ │ ├── test_float_io.cpp
│ │ │ ├── test_float_serial.hpp
│ │ │ ├── test_fpclassify.cpp
│ │ │ ├── test_gcd.cpp
│ │ │ ├── test_generic_conv.cpp
│ │ │ ├── test_gmp_conversions.cpp
│ │ │ ├── test_hash.cpp
│ │ │ ├── test_int_io.cpp
│ │ │ ├── test_int_sqrt.cpp
│ │ │ ├── test_log.cpp
│ │ │ ├── test_miller_rabin.cpp
│ │ │ ├── test_mixed.hpp
│ │ │ ├── test_mixed_cpp_bin_float.cpp
│ │ │ ├── test_mixed_cpp_dec_float.cpp
│ │ │ ├── test_mixed_cpp_int.cpp
│ │ │ ├── test_mixed_float.cpp
│ │ │ ├── test_mixed_move_cpp_int.cpp
│ │ │ ├── test_mixed_mpf_float.cpp
│ │ │ ├── test_mixed_mpfr_float.cpp
│ │ │ ├── test_move.cpp
│ │ │ ├── test_mpc_conversions.cpp
│ │ │ ├── test_mpc_overloads.cpp
│ │ │ ├── test_mpf_precisions.cpp
│ │ │ ├── test_mpfi.cpp
│ │ │ ├── test_mpfi_precisions.cpp
│ │ │ ├── test_mpfr_conversions.cpp
│ │ │ ├── test_mpfr_mpc_precisions.cpp
│ │ │ ├── test_native_integer.cpp
│ │ │ ├── test_nothrow_cpp_bin_float.cpp
│ │ │ ├── test_nothrow_cpp_dec_float.cpp
│ │ │ ├── test_nothrow_cpp_int.cpp
│ │ │ ├── test_nothrow_cpp_rational.cpp
│ │ │ ├── test_nothrow_float128.cpp
│ │ │ ├── test_nothrow_gmp.cpp
│ │ │ ├── test_nothrow_mpfr.cpp
│ │ │ ├── test_numeric_limits.cpp
│ │ │ ├── test_optional_compat.cpp
│ │ │ ├── test_pow.cpp
│ │ │ ├── test_preserve_all_precision.cpp
│ │ │ ├── test_preserve_component_precision.cpp
│ │ │ ├── test_preserve_related_precision.cpp
│ │ │ ├── test_preserve_source_precision.cpp
│ │ │ ├── test_preserve_target_precision.cpp
│ │ │ ├── test_rat_float_interconv.cpp
│ │ │ ├── test_rational_io.cpp
│ │ │ ├── test_roots_10k_digits.cpp
│ │ │ ├── test_round.cpp
│ │ │ ├── test_sf_import_c99.cpp
│ │ │ ├── test_signed_zero.cpp
│ │ │ ├── test_sin.cpp
│ │ │ ├── test_sin_near_half_pi.cpp
│ │ │ ├── test_sinh.cpp
│ │ │ ├── test_sqrt.cpp
│ │ │ ├── test_tan.cpp
│ │ │ ├── test_tanh.cpp
│ │ │ ├── test_test.cpp
│ │ │ ├── test_threaded_precision.cpp
│ │ │ ├── test_trailing_io_delim.cpp
│ │ │ ├── test_unchecked_cpp_int.cpp
│ │ │ ├── timer.hpp
│ │ │ └── ublas_interop/
│ │ │ ├── common/
│ │ │ │ ├── init.hpp
│ │ │ │ └── testhelper.hpp
│ │ │ ├── test1.cpp
│ │ │ ├── test1.hpp
│ │ │ ├── test11.cpp
│ │ │ ├── test12.cpp
│ │ │ ├── test13.cpp
│ │ │ ├── test2.cpp
│ │ │ ├── test2.hpp
│ │ │ ├── test21.cpp
│ │ │ ├── test22.cpp
│ │ │ ├── test23.cpp
│ │ │ ├── test3.cpp
│ │ │ ├── test3.hpp
│ │ │ ├── test31.cpp
│ │ │ ├── test32.cpp
│ │ │ ├── test33.cpp
│ │ │ ├── test4.cpp
│ │ │ ├── test4.hpp
│ │ │ ├── test42.cpp
│ │ │ ├── test43.cpp
│ │ │ ├── test5.cpp
│ │ │ ├── test5.hpp
│ │ │ ├── test52.cpp
│ │ │ ├── test53.cpp
│ │ │ ├── test6.cpp
│ │ │ ├── test6.hpp
│ │ │ ├── test62.cpp
│ │ │ ├── test63.cpp
│ │ │ ├── test7.cpp
│ │ │ ├── test7.hpp
│ │ │ ├── test71.cpp
│ │ │ ├── test72.cpp
│ │ │ └── test73.cpp
│ │ └── tools/
│ │ └── sincos.cpp
│ └── rapidcsv/
│ ├── .travis.yml
│ ├── CMakeLists.txt
│ ├── LICENSE
│ ├── README.md
│ ├── appveyor.yml
│ ├── doc/
│ │ ├── README.md
│ │ ├── rapidcsv_Converter.md
│ │ ├── rapidcsv_ConverterParams.md
│ │ ├── rapidcsv_Document.md
│ │ ├── rapidcsv_LabelParams.md
│ │ ├── rapidcsv_SeparatorParams.md
│ │ └── rapidcsv_no_converter.md
│ ├── examples/
│ │ ├── colhdr.csv
│ │ ├── colrowhdr.csv
│ │ ├── ex001.cpp
│ │ ├── ex002.cpp
│ │ ├── ex003.cpp
│ │ ├── ex004.cpp
│ │ ├── ex005.cpp
│ │ ├── ex006.cpp
│ │ ├── ex007.cpp
│ │ ├── ex008.cpp
│ │ ├── ex009.cpp
│ │ ├── nohdr.csv
│ │ ├── rowhdr.csv
│ │ └── semi.csv
│ ├── run.sh
│ ├── src/
│ │ └── rapidcsv.h
│ ├── tests/
│ │ ├── msft.csv
│ │ ├── perftest.h
│ │ ├── ptest001.cpp
│ │ ├── ptest002.cpp
│ │ ├── test001.cpp
│ │ ├── test002.cpp
│ │ ├── test003.cpp
│ │ ├── test004.cpp
│ │ ├── test005.cpp
│ │ ├── test006.cpp
│ │ ├── test007.cpp
│ │ ├── test008.cpp
│ │ ├── test009.cpp
│ │ ├── test010.cpp
│ │ ├── test011.cpp
│ │ ├── test012.cpp
│ │ ├── test013.cpp
│ │ ├── test014.cpp
│ │ ├── test015.cpp
│ │ ├── test016.cpp
│ │ ├── test017.cpp
│ │ ├── test018.cpp
│ │ ├── test019.cpp
│ │ ├── test020.cpp
│ │ ├── test021.cpp
│ │ ├── test022.cpp
│ │ ├── test023.cpp
│ │ ├── test024.cpp
│ │ ├── test025.cpp
│ │ ├── test026.cpp
│ │ ├── test027.cpp
│ │ ├── test028.cpp
│ │ ├── test029.cpp
│ │ ├── test030.cpp
│ │ ├── test031.cpp
│ │ ├── test032.cpp
│ │ ├── test033.cpp
│ │ ├── test034.cpp
│ │ ├── test035.cpp
│ │ ├── test036.cpp
│ │ ├── test037.cpp
│ │ ├── test038.cpp
│ │ ├── test039.cpp
│ │ ├── test040.cpp
│ │ ├── test040b.cpp
│ │ ├── test041.cpp
│ │ ├── test042.cpp
│ │ ├── test043.cpp
│ │ ├── test044.cpp
│ │ ├── test045.cpp
│ │ ├── test046.cpp
│ │ ├── test047.cpp
│ │ ├── test048.cpp
│ │ ├── test049.cpp
│ │ ├── test050.cpp
│ │ ├── test051.cpp
│ │ ├── test052.cpp
│ │ ├── test053.cpp
│ │ ├── test054.cpp
│ │ ├── test055.cpp
│ │ ├── test056.cpp
│ │ ├── test057.cpp
│ │ ├── test058.cpp
│ │ ├── test059.cpp
│ │ ├── test060.cpp
│ │ ├── test061.cpp
│ │ ├── test062.cpp
│ │ ├── test063.cpp
│ │ ├── test064.cpp
│ │ ├── test065.cpp
│ │ ├── test066.cpp
│ │ └── unittest.h
│ └── uncrustify.cfg
└── test.ipynb
Copy disabled (too large)
Download .txt
Showing preview only (16,756K chars total). Download the full file to get everything.
SYMBOL INDEX (11721 symbols across 1271 files)
FILE: examples/lesson01/GuessNumber.cpp
function main (line 8) | int main() {
function isCorrect (line 47) | bool isCorrect(int guess, int answer) {
FILE: examples/lesson02/fig02_01.cpp
function main (line 6) | int main() {
FILE: examples/lesson02/fig02_02.cpp
function main (line 6) | int main() {
FILE: examples/lesson02/fig02_03.cpp
function main (line 6) | int main() {
FILE: examples/lesson02/fig02_04.cpp
function main (line 6) | int main() {
FILE: examples/lesson02/fig02_05.cpp
function main (line 10) | int main() {
FILE: examples/lesson02/fig02_06.cpp
function main (line 7) | int main() {
FILE: examples/lesson03/fig03_01.cpp
function main (line 6) | int main() {
FILE: examples/lesson03/fig03_02.cpp
function main (line 7) | int main() {
FILE: examples/lesson03/fig03_03.cpp
function main (line 6) | int main() {
FILE: examples/lesson03/fig03_04.cpp
function main (line 6) | int main() {
FILE: examples/lesson03/fig03_05.cpp
function main (line 9) | int main() {
FILE: examples/lesson04/decimalformatter.h
function string_view (line 18) | struct std::formatter<decimal> : std::formatter<string_view> {
FILE: examples/lesson04/decimalformatter_fmt.h
function string_view (line 18) | struct fmt::formatter<decimal> : fmt::formatter<string_view> {
FILE: examples/lesson04/ex04_06.cpp
function main (line 5) | int main() {
FILE: examples/lesson04/fig04_01.cpp
function main (line 6) | int main() {
FILE: examples/lesson04/fig04_02.cpp
function main (line 6) | int main() {
FILE: examples/lesson04/fig04_03.cpp
function main (line 7) | int main() {
FILE: examples/lesson04/fig04_03fmt.cpp
function main (line 7) | int main() {
FILE: examples/lesson04/fig04_04.cpp
function main (line 8) | int main() {
FILE: examples/lesson04/fig04_04fmt.cpp
function main (line 8) | int main() {
FILE: examples/lesson04/fig04_05.cpp
function main (line 6) | int main() {
FILE: examples/lesson04/fig04_06.cpp
function main (line 7) | int main() {
FILE: examples/lesson04/fig04_06fmt.cpp
function main (line 7) | int main() {
FILE: examples/lesson04/fig04_07.cpp
function main (line 7) | int main() {
FILE: examples/lesson04/fig04_07_with_error.cpp
function main (line 6) | int main() {
FILE: examples/lesson04/fig04_07fmt.cpp
function main (line 7) | int main() {
FILE: examples/lesson04/fig04_08.cpp
function main (line 6) | int main() {
FILE: examples/lesson04/fig04_09.cpp
function main (line 6) | int main() {
FILE: examples/lesson04/fig04_10.cpp
function main (line 7) | int main() {
FILE: examples/lesson04/fig04_11.cpp
function main (line 8) | int main() {
FILE: examples/lesson04/fig04_12/fig04_12.cpp
function main (line 9) | int main() {
FILE: examples/lesson04/fig04_12/fmt/core.h
type monostate (line 266) | struct monostate {}
function namespace (line 273) | namespace internal {
function FMT_CONSTEXPR (line 375) | FMT_CONSTEXPR
function FMT_CONSTEXPR (line 394) | FMT_CONSTEXPR const Char* data() const { return data_; }
function FMT_CONSTEXPR (line 402) | FMT_CONSTEXPR const Char& operator[](size_t pos) const { return data_[po...
function FMT_CONSTEXPR (line 404) | FMT_CONSTEXPR void remove_prefix(size_t n) {
function compare (line 410) | int compare(basic_string_view other) const {
function true_type (line 448) | struct is_char<char> : std::true_type {}
function true_type (line 449) | struct is_char<wchar_t> : std::true_type {}
function true_type (line 450) | struct is_char<internal::char8_type> : std::true_type {}
function true_type (line 451) | struct is_char<char16_t> : std::true_type {}
function true_type (line 452) | struct is_char<char32_t> : std::true_type {}
type compile_string (line 495) | struct compile_string {}
function namespace (line 505) | namespace internal {
type error_handler (line 522) | struct error_handler {
function FMT_CONSTEXPR (line 578) | FMT_CONSTEXPR void advance_to(iterator it) {
function FMT_CONSTEXPR (line 586) | FMT_CONSTEXPR int next_arg_id() {
function FMT_CONSTEXPR (line 596) | FMT_CONSTEXPR void check_arg_id(int) {
function namespace (line 642) | namespace internal {
function on_error (line 1295) | void on_error(const char* message) { error_handler().on_error(message); }
function iterator (line 1298) | iterator out() { return out_; }
function advance_to (line 1301) | void advance_to(iterator it) { out_ = it; }
function set_data (line 1502) | void set_data(const internal::value<Context>* values) { values_ = values; }
function set_data (line 1503) | void set_data(const format_arg* args) { args_ = args; }
function format_arg (line 1505) | format_arg do_get(int index) const {
function format_arg (line 1556) | format_arg get(int index) const {
type format_args (line 1572) | struct format_args
FILE: examples/lesson04/fig04_12/fmt/format-inl.h
function fmt (line 36) | inline fmt::internal::null<> strerror_r(int, char*, ...) { return {}; }
function fmt (line 37) | inline fmt::internal::null<> strerror_s(char*, std::size_t, ...) { retur...
function FMT_BEGIN_NAMESPACE (line 39) | FMT_BEGIN_NAMESPACE
function FMT_FUNC (line 130) | FMT_FUNC void format_error_code(internal::buffer<char>& out, int error_c...
function FMT_FUNC (line 156) | FMT_FUNC void report_error(format_func func, int error_code,
function FMT_FUNC (line 166) | FMT_FUNC void fwrite_fully(const void* ptr, size_t size, size_t count,
function namespace (line 174) | namespace internal {
function Char (line 204) | Char internal::thousands_sep_impl(locale_ref) {
function Char (line 208) | Char internal::decimal_point_impl(locale_ref) {
function namespace (line 225) | namespace internal {
type boundaries (line 332) | struct boundaries {
function class (line 338) | class fp {
function assign (line 389) | assign(Double) {
function multiply (line 442) | inline uint64_t multiply(uint64_t lhs, uint64_t rhs) {
function fp (line 459) | inline fp operator*(fp x, fp y) { return {multiply(x.f, y.f), x.e + y.e ...
function fp (line 463) | inline fp get_cached_power(int min_exponent, int& pow10_exponent) {
function class (line 500) | class bigint {
function friend (line 618) | friend int compare(const bigint& lhs, const bigint& rhs) {
function friend (line 635) | friend int add_compare(const bigint& lhs1, const bigint& lhs2,
function assign_pow10 (line 659) | void assign_pow10(int exp) {
function square (line 678) | void square() {
function divmod_assign (line 710) | int divmod_assign(const bigint& divisor) {
function round_direction (line 733) | enum class round_direction { unknown, up, down };
function round (line 917) | struct grisu_shortest_handler {
function grisu_shortest_handler (line 1081) | grisu_shortest_handler handler{buf.data(), 0,
function fixed_handler (line 1098) | fixed_handler handler{buf.data(), 0, precision, -cached_exp10, fixed};
function is_digit (line 1169) | auto is_digit = [](char c) { return c >= '0' && c <= '9'; }
function FMT_FUNC (line 1234) | FMT_FUNC const char* utf8_decode(const char* buf, uint32_t* c, int* e) {
function bigint (line 1273) | struct formatter<internal::bigint> {
function FMT_FUNC (line 1297) | FMT_FUNC internal::utf8_to_utf16::utf8_to_utf16(string_view s) {
function FMT_FUNC (line 1328) | FMT_FUNC void format_system_error(internal::buffer<char>& out, int error...
function FMT_FUNC (line 1357) | FMT_FUNC void report_system_error(int error_code,
function FMT_FUNC (line 1362) | FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args a...
function FMT_FUNC (line 1393) | FMT_FUNC void vprint(string_view format_str, format_args args) {
FILE: examples/lesson04/fig04_12/fmt/format.h
function FMT_BEGIN_NAMESPACE (line 94) | FMT_BEGIN_NAMESPACE
function FMT_BEGIN_NAMESPACE (line 178) | FMT_BEGIN_NAMESPACE
function FMT_BEGIN_NAMESPACE (line 235) | FMT_BEGIN_NAMESPACE
type sentinel (line 481) | struct sentinel {}
function explicit (line 483) | explicit output_range(OutputIt it) : it_(it) {}
function use_grisu (line 550) | bool use_grisu() {
function namespace (line 588) | inline namespace literals {
function deallocate (line 636) | void deallocate() {
function Allocator (line 649) | Allocator(alloc) {
function FMT_API (line 724) | FMT_API format_error : public std::runtime_error {
function namespace (line 736) | namespace internal {
function Char (line 862) | Char thousands_sep(locale_ref loc) {
function wchar_t (line 865) | inline wchar_t thousands_sep(locale_ref loc) {
function Char (line 870) | Char decimal_point(locale_ref loc) {
function wchar_t (line 873) | inline wchar_t decimal_point(locale_ref loc) {
function Char (line 881) | Char* format_decimal(Char* buffer, UInt value, int num_digits,
function digits10 (line 908) | int digits10() FMT_NOEXCEPT {
function FMT_NOEXCEPT (line 911) | constexpr int digits10<int128_t>() FMT_NOEXCEPT { return 38; }
function FMT_NOEXCEPT (line 912) | constexpr int digits10<uint128_t>() FMT_NOEXCEPT { return 38; }
function Iterator (line 915) | Iterator format_decimal(Iterator out, UInt value, int num_digits,
function It (line 926) | It format_decimal(It out, UInt value, int num_digits) {
function class (line 975) | class utf8_to_utf16 {
function Char (line 1008) | const Char* data() const { return data_; }
function FMT_CONSTEXPR (line 1010) | FMT_CONSTEXPR Char& operator[](size_t index) { return data_[index]; }
function FMT_CONSTEXPR (line 1011) | FMT_CONSTEXPR const Char& operator[](size_t index) const {
function FMT_CONSTEXPR (line 1015) | static FMT_CONSTEXPR fill_t<Char> make() {
function namespace (line 1026) | namespace align {
function namespace (line 1031) | namespace sign {
type class (line 1061) | enum class
type float_specs (line 1068) | struct float_specs {
function promote_float (line 1218) | inline double promote_float(float value) { return static_cast<double>(va...
function handle_int_type_spec (line 1221) | void handle_int_type_spec(char spec, Handler&& handler) {
function handle_char_specs (line 1300) | void handle_char_specs(const basic_format_specs<Char>* specs,
function handle_cstring_type_spec (line 1310) | void handle_cstring_type_spec(Char spec, Handler&& handler) {
function check_string_type_spec (line 1320) | void check_string_type_spec(Char spec, ErrorHandler&& eh) {
function check_pointer_type_spec (line 1325) | void check_pointer_type_spec(Char spec, ErrorHandler&& eh) {
function FMT_CONSTEXPR (line 1333) | FMT_CONSTEXPR void on_dec() {}
function FMT_CONSTEXPR (line 1334) | FMT_CONSTEXPR void on_hex() {}
function FMT_CONSTEXPR (line 1335) | FMT_CONSTEXPR void on_bin() {}
function FMT_CONSTEXPR (line 1336) | FMT_CONSTEXPR void on_oct() {}
function FMT_CONSTEXPR (line 1337) | FMT_CONSTEXPR void on_num() {}
function FMT_CONSTEXPR (line 1339) | FMT_CONSTEXPR void on_error() {
function FMT_CONSTEXPR (line 1353) | FMT_CONSTEXPR void on_int() {
function FMT_CONSTEXPR (line 1356) | FMT_CONSTEXPR void on_char() {}
function FMT_CONSTEXPR (line 1365) | FMT_CONSTEXPR void on_string() {}
function FMT_CONSTEXPR (line 1366) | FMT_CONSTEXPR void on_pointer() {}
function OutputIt (line 1402) | OutputIt fill(OutputIt it, size_t n, const fill_t<Char>& fill) {
function decltype (line 1423) | auto reserve(std::size_t n) -> decltype(internal::reserve(out_, n)) {
type dec_writer (line 1507) | struct dec_writer {
function on_dec (line 1516) | void on_dec() {
type hex_writer (line 1522) | struct hex_writer {
function on_hex (line 1532) | void on_hex() {
function on_bin (line 1551) | void on_bin() {
function on_oct (line 1561) | void on_oct() {
type num_writer (line 1574) | struct num_writer {
function on_num (line 1603) | void on_num() {
function FMT_NORETURN (line 1623) | FMT_NORETURN void on_error() {
type bytes_writer (line 1642) | struct bytes_writer {
function write (line 1700) | void write(int value) { write_decimal(value); }
function write (line 1701) | void write(long value) { write_decimal(value); }
function write (line 1702) | void write(long long value) { write_decimal(value); }
function write (line 1704) | void write(unsigned value) { write_decimal(value); }
function write (line 1705) | void write(unsigned long value) { write_decimal(value); }
function write (line 1706) | void write(unsigned long long value) { write_decimal(value); }
function write (line 1709) | void write(int128_t value) { write_decimal(value); }
function write (line 1710) | void write(uint128_t value) { write_decimal(value); }
function write (line 1780) | void write(char value) {
function write (line 1791) | void write(string_view value) {
function write (line 1795) | void write(wstring_view value) {
function write_bytes (line 1815) | void write_bytes(string_view bytes, const format_specs& specs) {
function true_type (line 1833) | struct is_integral<int128_t> : std::true_type {}
function true_type (line 1834) | struct is_integral<uint128_t> : std::true_type {}
type char_writer (line 1848) | struct char_writer {
function write_char (line 1857) | void write_char(char_type value) {
function write_pointer (line 1864) | void write_pointer(const void* p) {
function FMT_DEPRECATED (line 1870) | FMT_DEPRECATED format_specs* spec() { return specs_; }
function format_specs (line 1871) | format_specs* specs() { return specs_; }
function iterator (line 1872) | iterator out() { return writer_.out(); }
function write (line 1874) | void write(bool value) {
function write (line 1879) | void write(const char_type* value) {
function iterator (line 1907) | iterator operator()(char_type value) {
function iterator (line 1913) | iterator operator()(bool value) {
function ErrorHandler (line 1928) | struct char_spec_handler : ErrorHandler {
function error_handler (line 1944) | struct cstring_spec_handler : internal::error_handler {
function iterator (line 1955) | iterator operator()(const char_type* value) {
function iterator (line 1962) | iterator operator()(basic_string_view<char_type> value) {
function iterator (line 1972) | iterator operator()(const void* value) {
function is_name_start (line 1980) | bool is_name_start(Char c) {
function parse_nonnegative_int (line 1987) | int parse_nonnegative_int(const Char*& begin, const Char* end,
function const (line 2019) | bool operator()(typename basic_format_arg<Context>::handle h) const {
function handler_ (line 2035) | handler_(eh) {}
function handler_ (line 2055) | handler_(eh) {}
function specs_ (line 2077) | specs_(specs) {}
function FMT_CONSTEXPR (line 2079) | FMT_CONSTEXPR specs_setter(const specs_setter& other)
function FMT_CONSTEXPR (line 2082) | FMT_CONSTEXPR void on_align(align_t align) { specs_.align = align; }
function FMT_CONSTEXPR (line 2086) | FMT_CONSTEXPR void on_plus() { specs_.sign = sign::plus; }
function FMT_CONSTEXPR (line 2087) | FMT_CONSTEXPR void on_minus() { specs_.sign = sign::minus; }
function FMT_CONSTEXPR (line 2088) | FMT_CONSTEXPR void on_space() { specs_.sign = sign::space; }
function FMT_CONSTEXPR (line 2089) | FMT_CONSTEXPR void on_hash() { specs_.alt = true; }
function FMT_CONSTEXPR (line 2091) | FMT_CONSTEXPR void on_zero() {
function FMT_CONSTEXPR (line 2096) | FMT_CONSTEXPR void on_width(int width) { specs_.width = width; }
function FMT_CONSTEXPR (line 2097) | FMT_CONSTEXPR void on_precision(int precision) {
function FMT_CONSTEXPR (line 2100) | FMT_CONSTEXPR void end_precision() {}
function FMT_CONSTEXPR (line 2102) | FMT_CONSTEXPR void on_type(Char type) {
function require_numeric_argument (line 2115) | void require_numeric_argument() {
function FMT_CONSTEXPR (line 2120) | FMT_CONSTEXPR void check_sign() {
function FMT_CONSTEXPR (line 2128) | FMT_CONSTEXPR void check_precision() {
function FMT_CONSTEXPR (line 2153) | FMT_CONSTEXPR void on_plus() {
function FMT_CONSTEXPR (line 2158) | FMT_CONSTEXPR void on_minus() {
function FMT_CONSTEXPR (line 2163) | FMT_CONSTEXPR void on_space() {
function FMT_CONSTEXPR (line 2168) | FMT_CONSTEXPR void on_hash() {
function FMT_CONSTEXPR (line 2173) | FMT_CONSTEXPR void on_zero() {
function FMT_CONSTEXPR (line 2178) | FMT_CONSTEXPR void end_precision() { checker_.check_precision(); }
function get_dynamic_spec (line 2186) | int get_dynamic_spec(FormatArg arg, ErrorHandler eh) {
type auto_id (line 2192) | struct auto_id {}
function typename (line 2195) | typename Context::format_arg get_arg(Context& ctx, int id) {
function on_dynamic_precision (line 2218) | void on_dynamic_precision(Id arg_id) {
function on_error (line 2223) | void on_error(const char* message) { context_.on_error(message); }
function FMT_CONSTEXPR (line 2229) | FMT_CONSTEXPR format_arg get_arg(auto_id) {
function FMT_CONSTEXPR (line 2233) | FMT_CONSTEXPR format_arg get_arg(int arg_id) {
function arg_id_kind (line 2247) | enum class arg_id_kind { none, index, name };
function typename (line 2627) | const typename ParseContext::char_type* parse_format_specs(
function FMT_CONSTEXPR (line 2650) | FMT_CONSTEXPR void on_text(const Char*, const Char*) {}
function FMT_CONSTEXPR (line 2652) | FMT_CONSTEXPR void on_arg_id() {
function FMT_CONSTEXPR (line 2656) | FMT_CONSTEXPR void on_arg_id(int id) {
function iterator (line 2775) | iterator operator()(typename basic_format_arg<context_type>::handle hand...
function FMT_API (line 2786) | FMT_API system_error : public std::runtime_error {
function FMT_API (line 2849) | FMT_API void report_system_error(int error_code,
function explicit (line 2893) | explicit format_int(long value) { format_signed(value); }
function explicit (line 2894) | explicit format_int(long long value) { format_signed(value); }
function explicit (line 2895) | explicit format_int(unsigned value) : str_(format_decimal(value)) {}
function explicit (line 2896) | explicit format_int(unsigned long value) : str_(format_decimal(value)) {}
function explicit (line 2897) | explicit format_int(unsigned long long value) : str_(format_decimal(valu...
type null_handler (line 3068) | struct null_handler
function on_align (line 3069) | void on_align(align_t) {}
function on_plus (line 3070) | void on_plus() {}
function on_minus (line 3071) | void on_minus() {}
function on_space (line 3072) | void on_space() {}
function on_hash (line 3073) | void on_hash() {}
function get_arg (line 3159) | void get_arg(int id) { arg = internal::get_arg(context, id); }
function on_arg_id (line 3161) | void on_arg_id() { get_arg(parse_context.next_arg_id()); }
function on_arg_id (line 3162) | void on_arg_id(int id) {
function on_arg_id (line 3166) | void on_arg_id(basic_string_view<Char> id) { arg = context.arg(id); }
function on_replacement_field (line 3168) | void on_replacement_field(const Char* p) {
function Char (line 3174) | const Char* on_format_specs(const Char* begin, const Char* end) {
function class (line 3219) | class bytes {
function bytes (line 3228) | struct formatter<bytes> {
function typename (line 3365) | typename buffer_context<Char>::iterator vformat_to(
function typename (line 3373) | inline typename buffer_context<Char>::iterator format_to(
function OutputIt (line 3415) | OutputIt format_to(OutputIt out, const S& format_str, Args&&... args) {
function namespace (line 3506) | namespace internal {
function namespace (line 3558) | inline namespace literals {
function FMT_END_NAMESPACE (line 3610) | FMT_END_NAMESPACE
FILE: examples/lesson04/fig04_12/format.cc
function FMT_BEGIN_NAMESPACE (line 10) | FMT_BEGIN_NAMESPACE
type FMT_INSTANTIATION_DEF_API (line 124) | struct FMT_INSTANTIATION_DEF_API
FILE: examples/lesson04/fig04_17.cpp
function main (line 11) | int main() {
FILE: examples/lesson04/fig04_17fmt.cpp
function main (line 11) | int main() {
FILE: examples/lesson05/cipher.h
function keyIndex (line 48) | size_t keyIndex{0}
function row (line 67) | const int row{std::toupper(secret.at(keyIndex)) - 'A'};
function keyIndex (line 101) | size_t keyIndex{0}
function row (line 118) | const int row{std::toupper(secret.at(keyIndex)) - 'A'};
function checkKey (line 159) | static void checkKey(std::string_view secret) {
FILE: examples/lesson05/ex05_31.cpp
function main (line 8) | int main() {
function mystery (line 17) | int mystery(int a, int b) {
FILE: examples/lesson05/fig05_01.cpp
function main (line 9) | int main() {
function maximum (line 20) | int maximum(int x, int y, int z) {
FILE: examples/lesson05/fig05_02.cpp
function main (line 7) | int main() {
FILE: examples/lesson05/fig05_03.cpp
function main (line 8) | int main() {
FILE: examples/lesson05/fig05_04.cpp
function main (line 8) | int main() {
FILE: examples/lesson05/fig05_05.cpp
function main (line 10) | int main() {
function rollDice (line 55) | int rollDice() {
FILE: examples/lesson05/fig05_06.cpp
function main (line 9) | int main() {
function square (line 16) | int square(int x) { // x is a local variable
FILE: examples/lesson05/fig05_07.cpp
function cube (line 9) | inline double cube(double side) {
function main (line 13) | int main() {
FILE: examples/lesson05/fig05_08.cpp
function main (line 9) | int main() {
function squareByValue (line 27) | int squareByValue(int number) {
function squareByReference (line 33) | void squareByReference(int& numberRef) {
FILE: examples/lesson05/fig05_09.cpp
function main (line 9) | int main() {
function boxVolume (line 28) | int boxVolume(int length, int width, int height) {
FILE: examples/lesson05/fig05_10.cpp
function square (line 7) | int square(int x) {
function square (line 13) | double square(double y) {
function main (line 18) | int main() {
FILE: examples/lesson05/fig05_11.cpp
function square (line 5) | int square(int x) {
function square (line 10) | double square(double y) {
function nothing1 (line 16) | void nothing1(int a, float b, char c, int& d) { }
function nothing2 (line 20) | int nothing2(char a, int b, float& c, double& d) {
function main (line 24) | int main() { }
FILE: examples/lesson05/fig05_12.cpp
function square (line 7) | int square(int x) {
function square (line 13) | double square(double y) {
function main (line 18) | int main() {
FILE: examples/lesson05/fig05_13.cpp
function main (line 7) | int main() {
FILE: examples/lesson05/fig05_14.cpp
function main (line 11) | int main() {
function cpp_int (line 25) | cpp_int factorial(int number) {
FILE: examples/lesson05/fig05_15.cpp
function main (line 9) | int main() {
function fibonacci (line 23) | long fibonacci(long number) {
FILE: examples/lesson05/fig05_16.cpp
function main (line 12) | int main() {
function useLocal (line 38) | void useLocal() {
function useStaticLocal (line 49) | void useStaticLocal() {
function useGlobal (line 60) | void useGlobal() {
FILE: examples/lesson05/fig05_17.cpp
function main (line 8) | int main() {
FILE: examples/lesson05/fig05_18.cpp
function main (line 8) | int main() {
FILE: examples/lesson05/fig05_19.cpp
function cube (line 4) | [[nodiscard]]
function main (line 9) | int main() {
FILE: examples/lesson05/fig05_20.cpp
function main (line 8) | int main() {
FILE: examples/lesson05/maximum.h
function T (line 5) | T maximumValue{value1}
FILE: examples/lesson06/fig06_01.cpp
function main (line 7) | int main() {
FILE: examples/lesson06/fig06_02.cpp
function main (line 7) | int main() {
FILE: examples/lesson06/fig06_03.cpp
function main (line 7) | int main() {
FILE: examples/lesson06/fig06_04.cpp
function main (line 7) | int main() {
FILE: examples/lesson06/fig06_05.cpp
function main (line 7) | int main() {
FILE: examples/lesson06/fig06_06.cpp
function main (line 7) | int main() {
FILE: examples/lesson06/fig06_07.cpp
function main (line 8) | int main() {
FILE: examples/lesson06/fig06_08.cpp
function main (line 7) | int main() {
FILE: examples/lesson06/fig06_09.cpp
function main (line 9) | int main() {
FILE: examples/lesson06/fig06_10.cpp
function main (line 10) | int main() {
function printArray (line 22) | void printArray(const std::array<std::array<int, columns>, rows>& a) {
FILE: examples/lesson06/fig06_11.cpp
function main (line 8) | int main() {
FILE: examples/lesson06/fig06_12.cpp
function multiply (line 8) | int multiply(int x, int y) {
function main (line 12) | int main() {
FILE: examples/lesson06/fig06_13.cpp
function main (line 9) | int main() {
FILE: examples/lesson06/fig06_14.cpp
function main (line 10) | int main() {
function outputVector (line 93) | void outputVector(const std::vector<int>& items) {
function inputVector (line 102) | void inputVector(std::vector<int>& items) {
FILE: examples/lesson07/fig07_01.cpp
function main (line 6) | int main() {
FILE: examples/lesson07/fig07_02.cpp
function main (line 8) | int main() {
function cubeByValue (line 17) | int cubeByValue(int n) {
FILE: examples/lesson07/fig07_03.cpp
function main (line 9) | int main() {
function cubeByReference (line 18) | void cubeByReference(int* nPtr) {
FILE: examples/lesson07/fig07_06.cpp
function main (line 7) | int main() {
FILE: examples/lesson07/fig07_07.cpp
function main (line 5) | int main() {
FILE: examples/lesson07/fig07_08.cpp
function main (line 4) | int main() {
FILE: examples/lesson07/fig07_09.cpp
function main (line 6) | int main() {
FILE: examples/lesson07/fig07_10.cpp
function main (line 9) | int main() {
function getSize (line 20) | size_t getSize(double* ptr) {
FILE: examples/lesson07/fig07_11.cpp
function main (line 6) | int main() {
FILE: examples/lesson07/fig07_12.cpp
function displayArray (line 12) | void displayArray(const int items[], size_t size) {
function displaySpan (line 20) | void displaySpan(std::span<const int> items) {
function times2 (line 27) | void times2(std::span<int> items) {
function main (line 33) | int main() {
FILE: examples/lesson07/fig07_13.cpp
function main (line 6) | int main(int argc, char* argv[]) {
FILE: examples/lesson07/fig07_14.cpp
function main (line 7) | int main() {
FILE: examples/lesson08/fig08_01.cpp
function main (line 7) | int main() {
FILE: examples/lesson08/fig08_02.cpp
function displayResult (line 7) | void displayResult(const std::string& s, int result) {
function main (line 19) | int main() {
FILE: examples/lesson08/fig08_03.cpp
function main (line 6) | int main() {
FILE: examples/lesson08/fig08_04.cpp
function main (line 7) | int main() {
FILE: examples/lesson08/fig08_05.cpp
function printStatistics (line 8) | void printStatistics(const std::string& s) {
function main (line 14) | int main() {
FILE: examples/lesson08/fig08_06.cpp
function main (line 7) | int main() {
FILE: examples/lesson08/fig08_07.cpp
function main (line 7) | int main() {
FILE: examples/lesson08/fig08_08.cpp
function main (line 7) | int main() {
FILE: examples/lesson08/fig08_09.cpp
function main (line 8) | int main() {
FILE: examples/lesson08/fig08_10.cpp
function main (line 9) | int main() {
FILE: examples/lesson08/fig08_11.cpp
function main (line 9) | int main() {
FILE: examples/lesson08/fig08_12.cpp
function main (line 7) | int main() {
FILE: examples/lesson08/fig08_13.cpp
function main (line 8) | int main() {
FILE: examples/lesson08/fig08_14.cpp
function main (line 8) | int main() {
FILE: examples/lesson08/fig08_15.cpp
function main (line 13) | int main() {
FILE: examples/lesson08/fig08_16.cpp
function main (line 7) | int main() {
FILE: examples/lesson08/fig08_17.cpp
function main (line 8) | int main() {
FILE: examples/lesson08/fig08_18.cpp
function main (line 8) | int main() {
FILE: examples/lesson08/format.cc
function FMT_BEGIN_NAMESPACE (line 10) | FMT_BEGIN_NAMESPACE
type FMT_INSTANTIATION_DEF_API (line 124) | struct FMT_INSTANTIATION_DEF_API
FILE: examples/lesson09/fig09_01-02/Account.h
function class (line 7) | class Account {
FILE: examples/lesson09/fig09_01-02/AccountTest.cpp
function main (line 8) | int main() {
FILE: examples/lesson09/fig09_03-04/Account.h
function class (line 6) | class Account {
FILE: examples/lesson09/fig09_03-04/AccountTest.cpp
function main (line 8) | int main() {
FILE: examples/lesson09/fig09_05-06/Account.h
function class (line 8) | class Account {
function deposit (line 17) | void deposit(double amount) {
function setName (line 29) | void setName(std::string_view name) {
FILE: examples/lesson09/fig09_05-06/AccountTest.cpp
function main (line 7) | int main() {
FILE: examples/lesson09/fig09_07-09/Time.h
function class (line 8) | class Time {
FILE: examples/lesson09/fig09_07-09/fig09_09.cpp
function displayTime (line 11) | void displayTime(std::string_view message, const Time& time) {
function main (line 16) | int main() {
FILE: examples/lesson09/fig09_10-12/Time.h
function class (line 8) | class Time {
FILE: examples/lesson09/fig09_10-12/fig09_12.cpp
function displayTime (line 10) | void displayTime(std::string_view message, const Time& time) {
function main (line 15) | int main() {
FILE: examples/lesson09/fig09_13-15/CreateAndDestroy.h
function class (line 8) | class CreateAndDestroy {
FILE: examples/lesson09/fig09_13-15/fig09_15.cpp
function main (line 11) | int main() {
function create (line 24) | void create() {
FILE: examples/lesson09/fig09_16-18/Time.h
function class (line 8) | class Time {
FILE: examples/lesson09/fig09_16-18/fig09_18.cpp
function main (line 8) | int main() {
FILE: examples/lesson09/fig09_19-21/Date.h
function class (line 7) | class Date {
FILE: examples/lesson09/fig09_19-21/fig09_21.cpp
function main (line 8) | int main() {
FILE: examples/lesson09/fig09_22/Time.h
function class (line 8) | class Time {
FILE: examples/lesson09/fig09_22/fig09_22.cpp
function main (line 5) | int main() {
FILE: examples/lesson09/fig09_23-27/Date.h
function class (line 6) | class Date {
FILE: examples/lesson09/fig09_23-27/Employee.h
function class (line 9) | class Employee {
FILE: examples/lesson09/fig09_23-27/fig09_27.cpp
function main (line 8) | int main() {
FILE: examples/lesson09/fig09_28/fig09_28.cpp
class Count (line 7) | class Count {
method getX (line 10) | int getX() const { return m_x; }
function modifyX (line 17) | void modifyX(Count& c, int value) {
function main (line 21) | int main() {
FILE: examples/lesson09/fig09_29/fig09_29.cpp
class Test (line 6) | class Test {
function main (line 32) | int main() {
FILE: examples/lesson09/fig09_30-32/Time.cpp
function Time (line 13) | Time& Time::setTime(int hour, int minute, int second) {
function Time (line 34) | Time& Time::setHour(int hour) {
function Time (line 39) | Time& Time::setMinute(int minute) {
function Time (line 44) | Time& Time::setSecond(int second) {
FILE: examples/lesson09/fig09_30-32/Time.h
function class (line 6) | class Time {
FILE: examples/lesson09/fig09_30-32/fig09_32.cpp
function main (line 8) | int main() {
FILE: examples/lesson09/fig09_33-35/Employee.cpp
function string (line 29) | const string& Employee::getFirstName() const {return m_firstName;}
function string (line 32) | const string& Employee::getLastName() const {return m_lastName;}
FILE: examples/lesson09/fig09_33-35/Employee.h
function class (line 8) | class Employee {
FILE: examples/lesson09/fig09_33-35/fig09_35.cpp
function main (line 7) | int main() {
FILE: examples/lesson09/fig09_36-37/cipher.h
function keyIndex (line 49) | size_t keyIndex{0}
function row (line 68) | const int row{std::toupper(secret.at(keyIndex)) - 'A'};
function keyIndex (line 102) | size_t keyIndex{0}
function row (line 119) | const int row{std::toupper(secret.at(keyIndex)) - 'A'};
function checkKey (line 160) | static void checkKey(std::string_view secret) {
FILE: examples/lesson09/fig09_36-37/fig09_36.cpp
function main (line 7) | int main() {
FILE: examples/lesson09/fig09_38/fig09_38.cpp
type Record (line 10) | struct Record {
function serialize (line 20) | void serialize(Archive& archive, Record& record) {
function displayRecords (line 28) | void displayRecords(const std::vector<Record>& records) {
function main (line 35) | int main() {
FILE: examples/lesson10/fig10_01-03/SalariedEmployee.h
function class (line 7) | class SalariedEmployee {
FILE: examples/lesson10/fig10_01-03/fig10_03.cpp
function main (line 7) | int main() {
FILE: examples/lesson10/fig10_04-06/SalariedCommissionEmployee.h
function m_commissionRate (line 23) | double m_commissionRate{0.0};
FILE: examples/lesson10/fig10_04-06/SalariedEmployee.h
function class (line 7) | class SalariedEmployee {
FILE: examples/lesson10/fig10_04-06/fig10_06.cpp
function main (line 7) | int main() {
FILE: examples/lesson10/fig10_07/SalariedCommissionEmployee.h
function m_commissionRate (line 23) | double m_commissionRate{0.0};
FILE: examples/lesson10/fig10_07/SalariedEmployee.h
function class (line 7) | class SalariedEmployee {
FILE: examples/lesson10/fig10_07/fig10_07.cpp
function main (line 9) | int main() {
FILE: examples/lesson10/fig10_08/SalariedCommissionEmployee.h
function m_commissionRate (line 23) | double m_commissionRate{0.0};
FILE: examples/lesson10/fig10_08/SalariedEmployee.h
function class (line 7) | class SalariedEmployee {
FILE: examples/lesson10/fig10_08/fig10_08.cpp
function main (line 6) | int main() {
FILE: examples/lesson10/fig10_09/SalariedCommissionEmployee.h
function m_commissionRate (line 23) | double m_commissionRate{0.0};
FILE: examples/lesson10/fig10_09/SalariedEmployee.h
function class (line 7) | class SalariedEmployee {
FILE: examples/lesson10/fig10_09/fig10_09.cpp
function main (line 8) | int main() {
FILE: examples/lesson10/fig10_10/SalariedCommissionEmployee.h
function m_commissionRate (line 23) | double m_commissionRate{0.0};
FILE: examples/lesson10/fig10_10/SalariedEmployee.h
function class (line 7) | class SalariedEmployee {
FILE: examples/lesson10/fig10_10/fig10_10.cpp
function main (line 8) | int main() {
FILE: examples/lesson10/fig10_11-17/Employee.h
function class (line 7) | class Employee {
FILE: examples/lesson10/fig10_11-17/fig10_17.cpp
function main (line 14) | int main() {
function virtualViaPointer (line 50) | void virtualViaPointer(const Employee* baseClassPtr) {
function virtualViaReference (line 57) | void virtualViaReference(const Employee& baseClassRef) {
FILE: examples/lesson10/fig10_19-26/Commission.h
function m_commissionRate (line 14) | double m_commissionRate{0.0}
FILE: examples/lesson10/fig10_19-26/CompensationModel.h
function class (line 6) | class CompensationModel {
FILE: examples/lesson10/fig10_19-26/Employee.h
function class (line 8) | class Employee final {
FILE: examples/lesson10/fig10_19-26/fig10_26.cpp
function main (line 10) | int main() {
FILE: examples/lesson11/fig11_01/fig11_01.cpp
function main (line 9) | int main() {
FILE: examples/lesson11/fig11_02/fig11_02.cpp
class Integer (line 7) | class Integer {
method Integer (line 10) | Integer(int i) : value{i} {
method getValue (line 19) | int getValue() const {return value;}
function main (line 25) | int main() {
FILE: examples/lesson11/fig11_03-05/MyArray.cpp
function MyArray (line 42) | MyArray& MyArray::operator=(const MyArray& right) {
function MyArray (line 57) | MyArray& MyArray::operator=(MyArray&& right) noexcept {
function string (line 76) | string MyArray::toString() const {
function MyArray (line 123) | MyArray& MyArray::operator++() {
function MyArray (line 131) | MyArray MyArray::operator++(int) {
function MyArray (line 138) | MyArray& MyArray::operator+=(int value) {
function istream (line 148) | istream& operator>>(istream& in, MyArray& a) {
function ostream (line 159) | ostream& operator<<(ostream& out, const MyArray& a) {
function swap (line 165) | void swap(MyArray& a, MyArray& b) noexcept {
FILE: examples/lesson11/fig11_03-05/MyArray.h
function class (line 8) | class MyArray final {
FILE: examples/lesson11/fig11_03-05/fig11_03.cpp
function MyArray (line 10) | MyArray getArrayByValue() {
function main (line 15) | int main() {
FILE: examples/lesson11/fig11_06/fig11_06.cpp
class Time (line 9) | class Time {
method Time (line 11) | Time(int hr, int min, int sec) noexcept
method string (line 14) | string toString() const {
function main (line 26) | int main() {
FILE: examples/lesson11/fig11_07/MyArray.cpp
function MyArray (line 42) | MyArray& MyArray::operator=(const MyArray& right) {
function MyArray (line 57) | MyArray& MyArray::operator=(MyArray&& right) noexcept {
function string (line 76) | string MyArray::toString() const {
function MyArray (line 123) | MyArray& MyArray::operator++() {
function MyArray (line 131) | MyArray MyArray::operator++(int) {
function MyArray (line 138) | MyArray& MyArray::operator+=(int value) {
function istream (line 148) | istream& operator>>(istream& in, MyArray& a) {
function ostream (line 159) | ostream& operator<<(ostream& out, const MyArray& a) {
function swap (line 165) | void swap(MyArray& a, MyArray& b) noexcept {
FILE: examples/lesson11/fig11_07/MyArray.h
function class (line 8) | class MyArray final {
FILE: examples/lesson11/fig11_07/fig11_07.cpp
function main (line 9) | int main() {
function outputArray (line 16) | void outputArray(const MyArray& arrayToOutput) {
FILE: examples/lesson11/fig11_08/MyArray.cpp
function MyArray (line 42) | MyArray& MyArray::operator=(const MyArray& right) {
function MyArray (line 57) | MyArray& MyArray::operator=(MyArray&& right) noexcept {
function string (line 76) | string MyArray::toString() const {
function MyArray (line 123) | MyArray& MyArray::operator++() {
function MyArray (line 131) | MyArray MyArray::operator++(int) {
function MyArray (line 138) | MyArray& MyArray::operator+=(int value) {
function istream (line 148) | istream& operator>>(istream& in, MyArray& a) {
function ostream (line 159) | ostream& operator<<(ostream& out, const MyArray& a) {
function swap (line 165) | void swap(MyArray& a, MyArray& b) noexcept {
FILE: examples/lesson11/fig11_08/MyArray.h
function class (line 8) | class MyArray final {
FILE: examples/lesson11/fig11_08/fig11_08.cpp
function main (line 9) | int main() {
function outputArray (line 17) | void outputArray(const MyArray& arrayToOutput) {
FILE: examples/lesson12/fig12_01-02/DivideByZeroException.h
function class (line 7) | class DivideByZeroException : public std::runtime_error {
FILE: examples/lesson12/fig12_01-02/fig12_02.cpp
function quotient (line 10) | double quotient(double numerator, double denominator) {
function main (line 20) | int main() {
FILE: examples/lesson12/fig12_03/fig12_03.cpp
function throwException (line 7) | void throwException() {
function main (line 22) | int main() {
FILE: examples/lesson12/fig12_04/fig12_04.cpp
function function3 (line 7) | void function3() {
function function2 (line 15) | void function2() {
function function1 (line 21) | void function1() {
function main (line 27) | int main() {
FILE: examples/lesson12/fig12_04/fig12_04modified.cpp
function function3 (line 7) | void function3() {
function function2 (line 15) | void function2() {
function function1 (line 21) | void function1() {
function main (line 27) | int main() {
FILE: examples/lesson12/fig12_05/fig12_05.cpp
class Integer (line 9) | class Integer {
method Integer (line 11) | explicit Integer(int i) : value{i} {
class ResourceManager (line 20) | class ResourceManager {
method ResourceManager (line 22) | ResourceManager(int i) try : myInteger(i) {
function main (line 34) | int main() {
FILE: examples/lesson12/fig12_06/fig12_06.cpp
function main (line 10) | int main() {
FILE: examples/lesson12/fig12_07/fig12_07.cpp
function customNewHandler (line 10) | void customNewHandler() {
function main (line 15) | int main() {
FILE: examples/lesson12/fig12_08/fig12_08.cpp
function main (line 8) | int main() {
function quotient (line 14) | double quotient(double numerator, double denominator) {
FILE: examples/lesson12/fig12_09/fig12_09.cpp
function binarySearch (line 8) | int binarySearch(const std::vector<T>& items, const T& key)
function main (line 34) | int main() {
FILE: examples/lesson13/fig13_01.cpp
function main (line 6) | int main() {
FILE: examples/lesson13/fig13_02.cpp
function showResult (line 9) | void showResult(int value, size_t size, size_t capacity) {
function main (line 14) | int main() {
FILE: examples/lesson13/fig13_03.cpp
function main (line 11) | int main() {
FILE: examples/lesson13/fig13_04.cpp
function printList (line 12) | void printList(const std::list<T>& items) {
function main (line 22) | int main() {
FILE: examples/lesson13/fig13_05.cpp
function main (line 8) | int main() {
FILE: examples/lesson13/fig13_06.cpp
function main (line 11) | int main() {
FILE: examples/lesson13/fig13_07.cpp
function main (line 9) | int main() {
FILE: examples/lesson13/fig13_08.cpp
function main (line 7) | int main() {
FILE: examples/lesson13/fig13_09.cpp
function main (line 7) | int main() {
FILE: examples/lesson13/fig13_10.cpp
function main (line 25) | int main() {
FILE: examples/lesson13/fig13_11.cpp
function main (line 6) | int main() {
FILE: examples/lesson13/fig13_12.cpp
function main (line 6) | int main() {
FILE: examples/lesson14/fig14_01.cpp
function main (line 8) | int main() {
FILE: examples/lesson14/fig14_02.cpp
function nextLetter (line 9) | char nextLetter() {
function main (line 14) | int main() {
FILE: examples/lesson14/fig14_03.cpp
function main (line 11) | int main() {
FILE: examples/lesson14/fig14_04.cpp
function main (line 8) | int main() {
FILE: examples/lesson14/fig14_05.cpp
function main (line 8) | int main() {
FILE: examples/lesson14/fig14_06.cpp
function main (line 9) | int main() {
FILE: examples/lesson14/fig14_07.cpp
function main (line 8) | int main() {
FILE: examples/lesson14/fig14_08.cpp
function main (line 8) | int main() {
FILE: examples/lesson14/fig14_09.cpp
function main (line 9) | int main() {
FILE: examples/lesson14/fig14_10.cpp
function main (line 9) | int main() {
FILE: examples/lesson14/fig14_11.cpp
function main (line 11) | int main() {
FILE: examples/lesson14/fig14_12.cpp
function main (line 9) | int main() {
FILE: examples/lesson14/fig14_13.cpp
function main (line 7) | int main() {
FILE: examples/lesson14/fig14_14.cpp
function main (line 10) | int main() {
FILE: examples/lesson14/fig14_15.cpp
function main (line 9) | int main() {
FILE: examples/lesson14/fig14_16.cpp
function sumSquares (line 12) | int sumSquares(int total, int value) {
class SumSquaresClass (line 19) | class SumSquaresClass {
function main (line 27) | int main() {
FILE: examples/lesson14/fig14_17.cpp
class Employee (line 11) | class Employee {
method Employee (line 13) | Employee(std::string_view first, std::string_view last, int salary)
method getFirst (line 15) | std::string getFirst() const {return m_first;}
method getLast (line 16) | std::string getLast() const {return m_last;}
method getSalary (line 17) | int getSalary() const {return m_salary;}
function main (line 31) | int main() {
FILE: examples/lesson14/fig14_18.cpp
function main (line 11) | int main() {
FILE: examples/lesson15/fig15_01-02/Stack.h
function push (line 13) | void push(const T& pushValue) {stack.push_front(pushValue);}
function pop (line 16) | void pop() {stack.pop_front();}
FILE: examples/lesson15/fig15_01-02/fig15_02.cpp
function main (line 6) | int main() {
FILE: examples/lesson15/fig15_03.cpp
function printContainer (line 10) | void printContainer(const auto& items) {
function main (line 16) | int main() {
FILE: examples/lesson15/fig15_04.cpp
function T (line 6) | T multiply(T first, T second) {return first * second;}
function main (line 8) | int main() {
FILE: examples/lesson15/fig15_05.cpp
function T (line 9) | T multiply(T first, T second) {return first * second;}
function main (line 11) | int main() {
FILE: examples/lesson15/fig15_06.cpp
function main (line 9) | int main() {
FILE: examples/lesson15/fig15_07.cpp
function multiply (line 11) | auto multiply(Numeric auto first, Numeric auto second) {
function main (line 15) | int main() {
FILE: examples/lesson15/fig15_08.cpp
function customDistance (line 12) | auto customDistance(Iterator begin, Iterator end) {
function customDistance (line 27) | auto customDistance(Iterator begin, Iterator end) {
function main (line 32) | int main() {
FILE: examples/lesson15/fig15_09.cpp
function multiply (line 10) | auto multiply(T a, T b) {
function main (line 15) | int main() {
FILE: examples/lesson15/fig15_10.cpp
function average (line 20) | auto average(NumericInputRange auto const& range) {
function main (line 31) | int main() {
FILE: examples/lesson15/fig15_11-12/MyArray.h
function m_ptr (line 28) | ConstIterator(pointer p) : m_ptr{p}
function ConstIterator (line 41) | ConstIterator temp{*this};
function reference (line 48) | reference operator*() const noexcept {return *m_ptr;}
function pointer (line 51) | pointer operator->() const noexcept {return m_ptr;}
function ConstIterator (line 70) | ConstIterator temp{*this};
function Iterator (line 104) | Iterator temp{*this};
function reference (line 112) | reference operator*() const noexcept {
function pointer (line 117) | pointer operator->() const noexcept {
function Iterator (line 132) | Iterator temp{*this};
function size_type (line 159) | constexpr size_type size() const noexcept {return SIZE;} // return size
function iterator (line 163) | iterator end() {return iterator{&m_data[0] + size()};}
function const_iterator (line 164) | const_iterator begin() const {return const_iterator{&m_data[0]};}
function throw (line 191) | throw std::out_of_range{"Index out of range"};
function T (line 199) | const T& operator[](size_type index) const {
FILE: examples/lesson15/fig15_11-12/fig15_12.cpp
function main (line 9) | int main() {
FILE: examples/lesson15/fig15_11-12/sorttest.cpp
function main (line 7) | int main() {
FILE: examples/lesson15/fig15_13.cpp
function Part (line 12) | Part getInventory(int partNumber) {
function main (line 25) | int main() {
FILE: examples/lesson15/fig15_14.cpp
function sum (line 9) | auto sum(T item) {
function sum (line 15) | auto sum(FirstItem first, RemainingItems... theRest) {
function foldingSum (line 21) | auto foldingSum(FirstItem first, RemainingItems... theRest) {
function main (line 25) | int main() {
FILE: examples/lesson15/fig15_15.cpp
function unaryLeftAdd (line 7) | auto unaryLeftAdd(Items... items) {
function unaryRightAdd (line 12) | auto unaryRightAdd(Items... items) {
function unaryLeftSubtract (line 17) | auto unaryLeftSubtract(Items... items) {
function unaryRightSubtract (line 22) | auto unaryRightSubtract(Items... items) {
function main (line 26) | int main() {
FILE: examples/lesson15/fig15_16.cpp
function binaryLeftAdd (line 7) | auto binaryLeftAdd(Items... items) {
function binaryRightAdd (line 12) | auto binaryRightAdd(Items... items) {
function binaryLeftSubtract (line 17) | auto binaryLeftSubtract(Items... items) {
function binaryRightSubtract (line 22) | auto binaryRightSubtract(Items... items) {
function main (line 26) | int main() {
FILE: examples/lesson15/fig15_17.cpp
function printItems (line 6) | void printItems(Items... items) {
function main (line 10) | int main() {
FILE: examples/lesson15/fig15_18.cpp
function foldingSum (line 14) | auto foldingSum(FirstItem first, RemainingItems... theRest) {
function main (line 18) | int main() {
FILE: examples/lesson15/fig15_19.cpp
type Factorial (line 7) | struct Factorial {
type Factorial<0> (line 13) | struct Factorial<0> {
function recursiveFactorial (line 18) | constexpr long long recursiveFactorial(int number) {
function iterativeFactorial (line 28) | constexpr long long iterativeFactorial(int number) {
function main (line 38) | int main() {
FILE: examples/lesson15/fig15_20.cpp
function customDistance (line 13) | auto customDistance(Iterator begin, Iterator end) {
function main (line 35) | int main() {
FILE: examples/lesson15/fig15_21.cpp
type my_add_const (line 9) | struct my_add_const {
type my_remove_ptr (line 15) | struct my_remove_ptr {
type my_remove_ptr<T*> (line 21) | struct my_remove_ptr<T*> {
function main (line 25) | int main() {
FILE: examples/lesson16/fig16_01/fig16_01.cpp
function main (line 5) | int main() {
FILE: examples/lesson16/fig16_02-03/fig16_03.cpp
function main (line 6) | int main() {
FILE: examples/lesson16/fig16_04-05/fig16_05.cpp
function main (line 6) | int main() {
FILE: examples/lesson16/fig16_06-08/deitel.math-impl.cpp
type deitel::math (line 8) | namespace deitel::math {
function average (line 10) | double average(const std::vector<int>& values) {
FILE: examples/lesson16/fig16_06-08/fig16_08.cpp
function main (line 9) | int main() {
FILE: examples/lesson16/fig16_09-11/fig16_11.cpp
function main (line 10) | int main() {
FILE: examples/lesson16/fig16_12-15/fig16_15.cpp
function main (line 8) | int main() {
FILE: examples/lesson16/fig16_12-15clang/fig16_15.cpp
function main (line 8) | int main() {
FILE: examples/lesson16/fig16_16-21/fig16_17.cpp
function main (line 8) | int main() {
FILE: examples/lesson16/fig16_16-21/fig16_19.cpp
function main (line 8) | int main() {
FILE: examples/lesson16/fig16_16-21/fig16_21.cpp
function main (line 8) | int main() {
FILE: examples/lesson16/fig16_16-21clang/fig16_17.cpp
function main (line 8) | int main() {
FILE: examples/lesson16/fig16_16-21clang/fig16_19.cpp
function main (line 8) | int main() {
FILE: examples/lesson16/fig16_16-21clang/fig16_21.cpp
function main (line 8) | int main() {
FILE: examples/lesson16/fig16_22/fig16_22.cpp
function main (line 5) | int main() {
FILE: examples/lesson16/fig16_25-27/fig16_27.cpp
function main (line 6) | int main() {
FILE: examples/lesson16/fig16_28-29/fig16_29.cpp
function main (line 7) | int main() {
FILE: examples/lesson17/fig17_01/fig17_01.cpp
function main (line 11) | int main() {
FILE: examples/lesson17/fig17_02/fig17_02.cpp
function timeTransform (line 13) | double timeTransform(auto policy, const std::vector<int>& v) {
function main (line 30) | int main() {
FILE: examples/lesson17/fig17_03-04/printtask.cpp
function main (line 12) | int main() {
FILE: examples/lesson17/fig17_03-04/printtask.h
function difference (line 36) | auto difference{duration_cast<milliseconds>(time - sleepTime)};
FILE: examples/lesson17/fig17_05-06/SharedBufferTest.cpp
function main (line 10) | int main() {
FILE: examples/lesson17/fig17_05-06/UnsynchronizedBuffer.h
function class (line 9) | class UnsynchronizedBuffer {
FILE: examples/lesson17/fig17_07-08/SharedBufferTest.cpp
function main (line 11) | int main() {
FILE: examples/lesson17/fig17_07-08/SynchronizedBuffer.h
function m_occupied (line 81) | bool m_occupied{false};
FILE: examples/lesson17/fig17_09-10/CircularBuffer.h
function m_occupiedCells (line 108) | int m_occupiedCells{0}
function m_writeIndex (line 109) | int m_writeIndex{0}
function m_readIndex (line 110) | int m_readIndex{0}; // index of next element to read
FILE: examples/lesson17/fig17_09-10/SharedBufferTest.cpp
function main (line 11) | int main() {
FILE: examples/lesson17/fig17_11/CooperativeCancelation.cpp
function id (line 16) | std::string id() {
function main (line 22) | int main() {
FILE: examples/lesson17/fig17_11/CooperativeCancelationFMT.cpp
function id (line 16) | std::string id() {
function main (line 22) | int main() {
FILE: examples/lesson17/fig17_12/async.cpp
function id (line 13) | std::string id() {
function FactorResults (line 27) | FactorResults getFactors(std::string name, long long number) {
function proveFactors (line 71) | void proveFactors(long long number, const Factors& factors) {
function displayResults (line 93) | void displayResults(const FactorResults& results) {
function main (line 119) | int main() {
FILE: examples/lesson17/fig17_13/atomic.cpp
function main (line 9) | int main() {
FILE: examples/lesson17/fig17_14/LatchDemo.cpp
function main (line 12) | int main() {
FILE: examples/lesson17/fig17_15/BarrierDemo.cpp
function main (line 11) | int main() {
FILE: examples/lesson17/fig17_16/SharedBufferTest.cpp
function main (line 11) | int main() {
FILE: examples/lesson17/fig17_16/SynchronizedBuffer.h
function get (line 30) | int get() {
function m_buffer (line 50) | int m_buffer{-1}; // shared by producer and consumer threads
FILE: examples/lesson18/fig18_01.cpp
function id (line 10) | std::string id() {
function fibonacciGenerator (line 17) | tl::generator<int> fibonacciGenerator(int limit) {
function main (line 37) | int main() {
FILE: examples/lesson18/fig18_02.cpp
function id (line 13) | std::string id() {
function printTask (line 21) | void printTask(std::string name, std::chrono::milliseconds sleep) {
function main (line 33) | int main() {
FILE: examples/lesson18/fig18_03.cpp
function id (line 14) | std::string id() {
function sortCoroutine (line 21) | concurrencpp::result<void> sortCoroutine(
function main (line 80) | int main() {
FILE: examples/lesson19/fig19_01.cpp
function main (line 5) | int main() {
FILE: examples/lesson19/fig19_02.cpp
function main (line 6) | int main() {
FILE: examples/lesson19/fig19_03.cpp
function main (line 6) | int main() {
FILE: examples/lesson19/fig19_04.cpp
function main (line 6) | int main() {
FILE: examples/lesson19/fig19_05.cpp
function main (line 5) | int main() {
FILE: examples/lesson19/fig19_06.cpp
function main (line 6) | int main() {
FILE: examples/lesson19/fig19_07.cpp
function main (line 7) | int main() {
FILE: examples/lesson19/fig19_08.cpp
function main (line 5) | int main() {
FILE: examples/lesson19/fig19_09.cpp
function main (line 16) | int main() {
FILE: examples/lesson19/fig19_10.cpp
function main (line 5) | int main() {
FILE: examples/lesson19/fig19_11.cpp
function main (line 6) | int main() {
FILE: examples/lesson19/fig19_12.cpp
function main (line 6) | int main() {
FILE: examples/lesson19/fig19_13.cpp
function main (line 7) | int main() {
FILE: examples/lesson19/fig19_14.cpp
function main (line 5) | int main() {
FILE: examples/lesson19/fig19_15.cpp
function main (line 6) | int main() {
FILE: examples/lesson19/fig19_16.cpp
function main (line 5) | int main() {
FILE: examples/lesson19/fig19_17.cpp
function main (line 5) | int main() {
FILE: examples/lesson19/fig19_18.cpp
function main (line 6) | int main() {
FILE: examples/lesson19/fig19_19.cpp
function main (line 5) | int main() {
FILE: examples/lesson19/fig19_20.cpp
function main (line 6) | int main() {
FILE: examples/lesson19/fig19_21.cpp
function main (line 6) | int main() {
FILE: examples/lesson19/fig19_22.cpp
function main (line 6) | int main() {
FILE: examples/lesson19/fig19_23.cpp
function main (line 6) | int main() {
FILE: examples/lesson20/fig20_01.cpp
function main (line 13) | int main() {
FILE: examples/lesson20/fig20_02.cpp
class TestMutable (line 6) | class TestMutable {
method TestMutable (line 8) | TestMutable(int v = 0) : value{v} {}
method getValue (line 10) | int getValue() const {
function main (line 17) | int main() {
FILE: examples/lesson20/fig20_03.cpp
type Example (line 9) | namespace Example {
type Inner (line 18) | namespace Inner {
type Years (line 20) | enum Years { fiscal1 = 2020, fiscal2, fiscal3 }
function main (line 29) | int main() {
FILE: examples/lesson20/fig20_04.cpp
function main (line 6) | int main() {
FILE: examples/lesson20/fig20_05.cpp
class Test (line 6) | class Test {
method Test (line 8) | Test(int x) : value{x} {}
method testFunction (line 10) | void testFunction() {
function main (line 20) | int main() {
function arrowStar (line 27) | void arrowStar(Test* ptr) {
function dotStar (line 33) | void dotStar(Test* ptr) {
FILE: examples/lesson20/fig20_06/Employee.h
function class (line 7) | class Employee {
FILE: examples/lesson20/fig20_06/fig20_06.cpp
function main (line 11) | int main() {
FILE: examples/lesson20/fig20_07.cpp
function cube (line 4) | [[nodiscard("Do not ignore! Otherwise, you won't know the cube of x.")]]
function main (line 9) | int main() {
FILE: examples/lesson20/fig20_08.cpp
class Book (line 12) | class Book {
method Book (line 14) | explicit Book(std::string_view bookTitle) : title{bookTitle} {}
function deleteBook (line 20) | void deleteBook(Book* book) {
function compareTitles (line 26) | bool compareTitles(
function main (line 31) | int main() {
FILE: examples/lesson20/fig20_09-13/Author.h
function class (line 11) | class Author {
FILE: examples/lesson20/fig20_09-13/Book.h
function class (line 11) | class Book {
FILE: examples/lesson20/fig20_09-13/fig20_13.cpp
function main (line 9) | int main() {
FILE: examples/lesson20/fig20_14.cpp
function T (line 10) | T sum(std::initializer_list<T> list) {
function main (line 21) | int main() {
FILE: examples/libraries/BigNumber/bin/BigNumber/include/bignumber.h
function class (line 32) | class BigNumber {
FILE: examples/libraries/BigNumber/main.cpp
function main (line 11) | int main() {
FILE: examples/libraries/BigNumber/src/bignumber.cpp
function BigNumber (line 38) | BigNumber BigNumber::add(BigNumber other) {
function BigNumber (line 72) | BigNumber BigNumber::addll(const long long &other) {
function BigNumber (line 76) | BigNumber BigNumber::addstr(const std::string &other) {
function BigNumber (line 81) | BigNumber BigNumber::subtract(BigNumber other) {
function BigNumber (line 201) | BigNumber BigNumber::subtractll(const long long &other) {
function BigNumber (line 205) | BigNumber BigNumber::subtractstr(const std::string &other) {
function BigNumber (line 209) | BigNumber BigNumber::multiply(BigNumber other) {
function BigNumber (line 262) | BigNumber BigNumber::multiplyll(const long long &other) {
function BigNumber (line 274) | BigNumber BigNumber::multiplystr(const std::string &other) {
function BigNumber (line 278) | BigNumber BigNumber::divide(BigNumber other) {
function BigNumber (line 305) | BigNumber BigNumber::dividell(const long long &other) {
function BigNumber (line 309) | BigNumber BigNumber::dividestr(const std::string &other) {
function BigNumber (line 313) | BigNumber BigNumber::pow(int exponent) {
function BigNumber (line 332) | BigNumber BigNumber::setString(const std::string &newStr) {
function BigNumber (line 337) | BigNumber BigNumber::negate() {
function BigNumber (line 347) | BigNumber BigNumber::trimLeadingZeros() {
function BigNumber (line 387) | BigNumber BigNumber::abs() const {
function BigNumber (line 396) | BigNumber operator+(BigNumber b1, const BigNumber &b2) {
function BigNumber (line 400) | BigNumber operator+(BigNumber b1, const long long &b2) {
function BigNumber (line 404) | BigNumber operator+(BigNumber b1, const std::string &b2) {
function BigNumber (line 408) | BigNumber operator-(BigNumber b1, const BigNumber &b2) {
function BigNumber (line 412) | BigNumber operator-(BigNumber b1, const long long &b2) {
function BigNumber (line 416) | BigNumber operator-(BigNumber b1, const std::string &b2) {
function BigNumber (line 420) | BigNumber operator*(BigNumber b1, const BigNumber &b2) {
function BigNumber (line 424) | BigNumber operator*(BigNumber b1, const long long &b2) {
function BigNumber (line 428) | BigNumber operator*(BigNumber b1, const std::string &b2) {
function BigNumber (line 432) | BigNumber operator/(BigNumber b1, const BigNumber &b2) {
function BigNumber (line 436) | BigNumber operator/(BigNumber b1, const long long &b2) {
function BigNumber (line 440) | BigNumber operator/(BigNumber b1, const std::string &b2) {
function BigNumber (line 444) | BigNumber operator^(BigNumber b1, const int &b2) {
function BigNumber (line 514) | BigNumber& BigNumber::operator=(const BigNumber &other) {
function BigNumber (line 519) | BigNumber& BigNumber::operator=(const long long &other) {
function BigNumber (line 524) | BigNumber& BigNumber::operator=(const std::string &other) {
function BigNumber (line 529) | BigNumber& BigNumber::operator+=(const BigNumber &other) {
function BigNumber (line 534) | BigNumber& BigNumber::operator+=(const long long &other) {
function BigNumber (line 539) | BigNumber& BigNumber::operator+=(const std::string &other) {
function BigNumber (line 544) | BigNumber& BigNumber::operator-=(const BigNumber &other) {
function BigNumber (line 549) | BigNumber& BigNumber::operator-=(const long long &other) {
function BigNumber (line 554) | BigNumber& BigNumber::operator-=(const std::string &other) {
function BigNumber (line 559) | BigNumber& BigNumber::operator*=(const BigNumber &other) {
function BigNumber (line 564) | BigNumber& BigNumber::operator*=(const long long &other) {
function BigNumber (line 569) | BigNumber& BigNumber::operator*=(const std::string &other) {
function BigNumber (line 574) | BigNumber& BigNumber::operator/=(const BigNumber &other) {
function BigNumber (line 579) | BigNumber& BigNumber::operator/=(const long long &other) {
function BigNumber (line 584) | BigNumber& BigNumber::operator/=(const std::string &other) {
function BigNumber (line 589) | BigNumber& BigNumber::operator++() {
function BigNumber (line 594) | BigNumber& BigNumber::operator--() {
function BigNumber (line 599) | BigNumber BigNumber::operator++(int) {
function BigNumber (line 605) | BigNumber BigNumber::operator--(int) {
FILE: examples/libraries/BigNumber/src/bignumber.h
function class (line 32) | class BigNumber {
FILE: examples/libraries/GSL/tests/algorithm_tests.cpp
type gsl (line 28) | namespace gsl
type fail_fast (line 30) | struct fail_fast
function TEST (line 36) | TEST(algorithm_tests, same_type)
function TEST (line 111) | TEST(algorithm_tests, compatible_type)
function TEST (line 187) | TEST(algorithm_tests, incompatible_type)
function TEST (line 205) | TEST(algorithm_tests, small_destination_span)
FILE: examples/libraries/GSL/tests/assertion_tests.cpp
function f (line 26) | int f(int i)
function g (line 32) | int g(int i)
function TEST (line 40) | TEST(assertion_tests, expects)
function TEST (line 52) | TEST(assertion_tests, ensures)
FILE: examples/libraries/GSL/tests/at_tests.cpp
function TEST (line 31) | TEST(at_tests, static_array)
function TEST (line 52) | TEST(at_tests, std_array)
function TEST (line 73) | TEST(at_tests, std_vector)
function TEST (line 94) | TEST(at_tests, InitializerList)
function test_constexpr (line 115) | static constexpr bool test_constexpr()
FILE: examples/libraries/GSL/tests/bounds_tests.cpp
function use (line 28) | void use(std::ptrdiff_t&) {}
function TEST (line 31) | TEST(bounds_tests, basic_bounds)
function TEST (line 43) | TEST(bounds_tests, bounds_basic)
function TEST (line 52) | TEST(bounds_tests, arrayview_iterator)
function TEST (line 70) | TEST(bounds_tests, bounds_convertible)
FILE: examples/libraries/GSL/tests/byte_tests.cpp
function modify_both (line 26) | int modify_both(gsl::byte& b, int& i)
function TEST (line 33) | TEST(byte_tests, construction)
function TEST (line 64) | TEST(byte_tests, bitwise_operations)
function TEST (line 100) | TEST(byte_tests, to_integer)
function TEST (line 118) | TEST(byte_tests, aliasing)
FILE: examples/libraries/GSL/tests/multi_span_tests.cpp
type gsl (line 32) | namespace gsl
type fail_fast (line 34) | struct fail_fast
type BaseClass (line 43) | struct BaseClass
type DerivedClass (line 46) | struct DerivedClass : BaseClass
function overloaded_func (line 50) | void overloaded_func(multi_span<const int, dynamic_range, 3, 5> exp, int...
function overloaded_func (line 55) | void overloaded_func(multi_span<const char, dynamic_range, 3, 5> exp, ch...
function iterate_second_column (line 60) | void iterate_second_column(multi_span<int, dynamic_range, dynamic_range>...
function fn (line 116) | void fn(const Bounds&)
function TEST (line 123) | TEST(multi_span_test, default_constructor)
function TEST (line 164) | TEST(multi_span_test, from_nullptr_constructor)
function TEST (line 215) | TEST(multi_span_test, from_nullptr_length_constructor) {
function TEST (line 276) | TEST(multi_span_test, from_element_constructor)
function TEST (line 331) | TEST(multi_span_test, from_pointer_length_constructor)
function TEST (line 370) | TEST(multi_span_test, from_pointer_pointer_constructor)
function TEST (line 432) | TEST(multi_span_test, from_array_constructor)
function TEST (line 573) | TEST(multi_span_test, from_dynamic_array_constructor)
function TEST (line 610) | TEST(multi_span_test, from_std_array_constructor)
function TEST (line 678) | TEST(multi_span_test, from_const_std_array_constructor)
function TEST (line 730) | TEST(multi_span_test, from_container_constructor)
function TEST (line 808) | TEST(multi_span_test, from_convertible_span_constructor)
function TEST (line 840) | TEST(multi_span_test, copy_move_and_assignment)
function TEST (line 866) | TEST(multi_span_test, as_multi_span_reshape)
function TEST (line 887) | TEST(multi_span_test, first)
function TEST (line 936) | TEST(multi_span_test, last)
function TEST (line 984) | TEST(multi_span_test, subspan)
function TEST (line 1065) | TEST(multi_span_test, rank)
function TEST (line 1086) | TEST(multi_span_test, extent)
function TEST (line 1135) | TEST(multi_span_test, operator_function_call)
function TEST (line 1168) | TEST(multi_span_test, comparison_operators)
function TEST (line 1281) | TEST(multi_span_test, basics)
function TEST (line 1290) | TEST(multi_span_test, bounds_checks)
function TEST (line 1319) | TEST(multi_span_test, span_parameter_test)
function TEST (line 1339) | TEST(multi_span_test, md_access)
function TEST (line 1375) | TEST(multi_span_test, as_multi_span)
function TEST (line 1432) | TEST(multi_span_test, empty_spans)
function TEST (line 1467) | TEST(multi_span_test, index_constructor)
function TEST (line 1493) | TEST(multi_span_test, index_constructors)
function TEST (line 1565) | TEST(multi_span_test, index_operations)
function TEST (line 1620) | TEST(multi_span_test, span_section_iteration)
function TEST (line 1646) | TEST(multi_span_test, dynamic_span_section_iteration)
function TEST (line 1676) | TEST(multi_span_test, span_structure_size)
function TEST (line 1702) | TEST(multi_span_test, fixed_size_conversions)
function TEST (line 1804) | TEST(multi_span_test, as_writeable_bytes)
function TEST (line 1832) | TEST(multi_span_test, iterator)
FILE: examples/libraries/GSL/tests/no_exception_ensure_tests.cpp
function operator_subscript_no_throw (line 20) | int operator_subscript_no_throw() noexcept
function test_terminate (line 27) | [[noreturn]] void test_terminate() { std::exit(0); }
function setup_termination_handler (line 29) | void setup_termination_handler() noexcept
function main (line 43) | int main() noexcept
FILE: examples/libraries/GSL/tests/notnull_tests.cpp
type MyBase (line 35) | struct MyBase
type MyDerived (line 38) | struct MyDerived : public MyBase
type Unrelated (line 41) | struct Unrelated
type RefCounted (line 47) | struct RefCounted
method RefCounted (line 49) | RefCounted(T* p) : p_(p) {}
type CustomPtr (line 56) | struct CustomPtr
method CustomPtr (line 58) | CustomPtr(T* p) : p_(p) {}
type NonCopyableNonMovable (line 112) | struct NonCopyableNonMovable
method NonCopyableNonMovable (line 114) | NonCopyableNonMovable() = default;
method NonCopyableNonMovable (line 115) | NonCopyableNonMovable(const NonCopyableNonMovable&) = delete;
method NonCopyableNonMovable (line 116) | NonCopyableNonMovable& operator=(const NonCopyableNonMovable&) = delete;
method NonCopyableNonMovable (line 117) | NonCopyableNonMovable(NonCopyableNonMovable&&) = delete;
method NonCopyableNonMovable (line 118) | NonCopyableNonMovable& operator=(NonCopyableNonMovable&&) = delete;
function TEST (line 242) | TEST(notnull_tests, TestNotNullostream)
function TEST (line 253) | TEST(notnull_tests, TestNotNullCasting)
function TEST (line 276) | TEST(notnull_tests, TestNotNullAssignment)
function TEST (line 291) | TEST(notnull_tests, TestNotNullRawPointerComparison)
function TEST (line 319) | TEST(notnull_tests, TestNotNullDereferenceOperator)
function TEST (line 349) | TEST(notnull_tests, TestNotNullSharedPtrComparison)
function TEST (line 380) | TEST(notnull_tests, TestNotNullCustomPtrComparison)
function TEST (line 414) | TEST(notnull_tests, TestNotNullConstructorTypeDeduction)
function TEST (line 475) | TEST(notnull_tests, TestMakeNotNull)
FILE: examples/libraries/GSL/tests/owner_tests.cpp
function f (line 24) | void f(int* i) { *i += 1; }
function TEST (line 26) | TEST(owner_tests, basic_test)
function TEST (line 35) | TEST(owner_tests, check_pointer_constraint)
FILE: examples/libraries/GSL/tests/span_compatibility_tests.cpp
type Base (line 35) | struct Base
type Derived (line 38) | struct Derived : Base
function ArrayConvertibilityCheck (line 48) | void ArrayConvertibilityCheck()
function TEST (line 72) | TEST(span_compatibility_tests, assertion_tests)
FILE: examples/libraries/GSL/tests/span_ext_tests.cpp
function TEST (line 34) | TEST(span_ext_test, make_span_from_pointer_length_constructor)
function TEST (line 64) | TEST(span_ext_test, make_span_from_pointer_pointer_construction)
function TEST (line 90) | TEST(span_ext_test, make_span_from_array_constructor)
function TEST (line 115) | TEST(span_ext_test, make_span_from_dynamic_array_constructor)
function TEST (line 128) | TEST(span_ext_test, make_span_from_std_array_constructor)
function TEST (line 157) | TEST(span_ext_test, make_span_from_const_std_array_constructor)
function TEST (line 168) | TEST(span_ext_test, make_span_from_std_array_const_constructor)
function TEST (line 179) | TEST(span_ext_test, make_span_from_container_constructor)
function TEST (line 195) | TEST(span_test, interop_with_gsl_at)
function TEST (line 203) | TEST(span_ext_test, iterator_free_functions)
function TEST (line 233) | TEST(span_ext_test, ssize_free_function)
function TEST (line 242) | TEST(span_ext_test, comparison_operators)
FILE: examples/libraries/GSL/tests/span_tests.cpp
type BaseClass (line 41) | struct BaseClass
type DerivedClass (line 44) | struct DerivedClass : BaseClass
type AddressOverloaded (line 47) | struct AddressOverloaded
method AddressOverloaded (line 52) | AddressOverloaded
function TEST (line 60) | TEST(span_test, constructors)
function TEST (line 71) | TEST(span_test, constructors_with_extent)
function TEST (line 82) | TEST(span_test, constructors_with_bracket_init)
function TEST (line 93) | TEST(span_test, size_optimization)
function TEST (line 102) | TEST(span_test, from_nullptr_size_constructor)
function TEST (line 148) | TEST(span_test, from_pointer_length_constructor)
function TEST (line 201) | TEST(span_test, from_pointer_pointer_construction)
function TEST (line 267) | TEST(span_test, from_array_constructor)
function TEST (line 363) | TEST(span_test, from_dynamic_array_constructor)
function TEST (line 376) | TEST(span_test, from_std_array_constructor)
function TEST (line 456) | TEST(span_test, from_const_std_array_constructor)
function TEST (line 506) | TEST(span_test, from_std_array_const_constructor)
function TEST (line 545) | TEST(span_test, from_container_constructor)
function TEST (line 633) | TEST(span_test, from_convertible_span_constructor){{span<DerivedClass> avd;
function TEST (line 667) | TEST(span_test, copy_move_and_assignment)
function TEST (line 692) | TEST(span_test, first)
function TEST (line 734) | TEST(span_test, last)
function TEST (line 775) | TEST(span_test, subspan)
function TEST (line 860) | TEST(span_test, iterator_default_init)
function TEST (line 867) | TEST(span_test, iterator_comparisons)
function TEST (line 897) | TEST(span_test, incomparable_iterators)
function TEST (line 919) | TEST(span_test, begin_end)
function TEST (line 977) | TEST(span_test, rbegin_rend)
function TEST (line 1026) | TEST(span_test, as_bytes)
function TEST (line 1066) | TEST(span_test, as_writable_bytes)
function TEST (line 1099) | TEST(span_test, fixed_size_conversions)
function TEST (line 1200) | TEST(span_test, interop_with_std_regex)
function TEST (line 1223) | TEST(span_test, default_constructible)
function TEST (line 1230) | TEST(span_test, front_back)
FILE: examples/libraries/GSL/tests/strict_notnull_tests.cpp
type gsl (line 20) | namespace gsl
type fail_fast (line 22) | struct fail_fast
FILE: examples/libraries/GSL/tests/strided_span_tests.cpp
type BaseClass (line 36) | struct BaseClass
type DerivedClass (line 39) | struct DerivedClass : BaseClass
function TEST (line 111) | TEST(strided_span_tests, span_section)
function TEST (line 131) | TEST(strided_span_tests, strided_span_constructors)
function TEST (line 337) | TEST(strided_span_tests, strided_span_slice)
function TEST (line 363) | TEST(strided_span_tests, strided_span_column_major)
function TEST (line 395) | TEST(strided_span_tests, strided_span_bounds)
function TEST (line 516) | TEST(strided_span_tests, strided_span_type_conversion)
function TEST (line 618) | TEST(strided_span_tests, empty_strided_spans)
function TEST (line 656) | TEST(strided_span_tests, strided_span_section_iteration)
function TEST (line 673) | TEST(strided_span_tests, dynamic_strided_span_section_iteration)
function TEST (line 687) | TEST(strided_span_tests, strided_span_section_iteration_3d)
function TEST (line 701) | TEST(strided_span_tests, dynamic_strided_span_section_iteration_3d)
function TEST (line 733) | TEST(strided_span_tests, strided_span_conversion)
FILE: examples/libraries/GSL/tests/string_span_tests.cpp
type generic (line 40) | namespace generic
function strlen (line 44) | auto strlen(const CharT* s)
function strnlen (line 52) | auto strnlen(const CharT* s, std::size_t n)
function T (line 63) | T move_wrapper(T&& t)
function T (line 72) | T create()
function use (line 78) | void use(basic_string_span<T, gsl::dynamic_extent>)
function CreateTempName (line 83) | czstring_span<> CreateTempName(string_span<> span)
function CreateTempNameW (line 100) | cwzstring_span<> CreateTempNameW(wstring_span<> span)
function CreateTempNameU16 (line 117) | cu16zstring_span<> CreateTempNameU16(u16string_span<> span)
function CreateTempNameU32 (line 134) | cu32zstring_span<> CreateTempNameU32(u32string_span<> span)
function TEST (line 152) | TEST(string_span_tests, TestLiteralConstruction)
function TEST (line 162) | TEST(string_span_tests, TestConstructFromStdString)
function TEST (line 169) | TEST(string_span_tests, TestConstructFromStdVector)
function TEST (line 176) | TEST(string_span_tests, TestStackArrayConstruction)
function TEST (line 201) | TEST(string_span_tests, TestConstructFromConstCharPointer)
function TEST (line 208) | TEST(string_span_tests, TestConversionToConst)
function TEST (line 216) | TEST(string_span_tests, TestConversionFromConst)
function TEST (line 227) | TEST(string_span_tests, TestToString)
function TEST (line 239) | TEST(string_span_tests, TestToBasicString)
function TEST (line 252) | TEST(string_span_tests, EqualityAndImplicitConstructors)
function TEST (line 478) | TEST(string_span_tests, ComparisonAndImplicitConstructors)
function TEST (line 549) | TEST(string_span_tests, ConstrutorsEnsureZ)
function TEST (line 579) | TEST(string_span_tests, Constructors)
function TEST (line 868) | TEST(string_span_tests, MoveConstructors)
function TEST (line 942) | TEST(string_span_tests, Conversion)
function TEST (line 951) | TEST(string_span_tests, zstring)
function TEST (line 992) | TEST(string_span_tests, wzstring)
function TEST (line 1033) | TEST(string_span_tests, u16zstring)
function TEST (line 1074) | TEST(string_span_tests, u32zstring)
function TEST (line 1115) | TEST(string_span_tests, Issue305)
function TEST (line 1122) | TEST(string_span_tests, char16_t_type)
function TEST (line 1163) | TEST(string_span_tests, char32_t_type)
function TEST (line 1200) | TEST(string_span_tests, as_bytes)
function TEST (line 1209) | TEST(string_span_tests, as_writable_bytes)
FILE: examples/libraries/GSL/tests/utils_tests.cpp
function f (line 32) | void f(int& i) { i += 1; }
function g (line 34) | void g() { j += 1; }
function TEST (line 38) | TEST(utils_tests, sanity_check_for_gsl_index_typedef)
function TEST (line 44) | TEST(utils_tests, finally_lambda)
function TEST (line 54) | TEST(utils_tests, finally_lambda_move)
function TEST (line 73) | TEST(utils_tests, finally_function_with_bind)
function TEST (line 83) | TEST(utils_tests, finally_function_ptr)
function TEST (line 93) | TEST(utils_tests, narrow_cast)
function TEST (line 104) | TEST(utils_tests, narrow)
FILE: examples/libraries/cereal-1.3.0/include/cereal/access.hpp
type cereal (line 41) | namespace cereal
type LoadAndConstruct (line 108) | struct LoadAndConstruct
type memory_detail (line 113) | namespace memory_detail{ template <class Ar, class T> struct LoadAndCo...
type LoadAndConstructLoadWrapper (line 113) | struct LoadAndConstructLoadWrapper
type boost_variant_detail (line 114) | namespace boost_variant_detail{ template <class Ar, class T> struct Lo...
type LoadAndConstructLoadWrapper (line 114) | struct LoadAndConstructLoadWrapper
class construct (line 164) | class construct
method T (line 185) | T * operator->()
method T (line 201) | T * ptr()
method construct (line 210) | construct( T * p ) : itsPtr( p ), itsEnableSharedRestoreFunction( []...
method construct (line 211) | construct( T * p, std::function<void()> enableSharedFunc ) : // g++4...
method construct (line 213) | construct( construct const & ) = delete;
method construct (line 214) | construct & operator=( construct const & ) = delete;
class access (line 240) | class access
method member_serialize (line 244) | inline
method member_save (line 248) | inline
method member_save_non_const (line 252) | inline
method member_load (line 256) | inline
method member_save_minimal (line 260) | inline
method member_save_minimal_non_const (line 264) | inline
method member_load_minimal (line 268) | inline
method member_serialize (line 273) | inline
method member_save (line 277) | inline
method member_save_non_const (line 281) | inline
method member_load (line 285) | inline
method member_save_minimal (line 289) | inline
method member_save_minimal_non_const (line 293) | inline
method member_load_minimal (line 297) | inline
method construct (line 307) | inline
method T (line 314) | inline
method load_and_construct (line 320) | inline
method load_and_construct (line 324) | inline
method load_and_construct (line 330) | inline
FILE: examples/libraries/cereal-1.3.0/include/cereal/archives/adapters.hpp
type cereal (line 36) | namespace cereal
class UserDataAdapter (line 109) | class UserDataAdapter : public Archive
method UserDataAdapter (line 120) | UserDataAdapter( UserData & ud, Args && ... args ) :
method rtti (line 127) | void rtti() {}
function UserData (line 149) | UserData & get_user_data( Archive & ar )
FILE: examples/libraries/cereal-1.3.0/include/cereal/archives/binary.hpp
type cereal (line 35) | namespace cereal
class BinaryOutputArchive (line 51) | class BinaryOutputArchive : public OutputArchive<BinaryOutputArchive, ...
method BinaryOutputArchive (line 57) | BinaryOutputArchive(std::ostream & stream) :
method saveBinary (line 65) | void saveBinary( const void * data, std::streamsize size )
class BinaryInputArchive (line 88) | class BinaryInputArchive : public InputArchive<BinaryInputArchive, All...
method BinaryInputArchive (line 92) | BinaryInputArchive(std::istream & stream) :
method loadBinary (line 100) | void loadBinary( void * const data, std::streamsize size )
function CEREAL_SAVE_FUNCTION_NAME (line 116) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 124) | inline
function CEREAL_SERIALIZE_FUNCTION_NAME (line 134) | CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, NameValuePair<T> & t )
function CEREAL_SERIALIZE_FUNCTION_NAME (line 142) | CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, SizeTag<T> & t )
function CEREAL_SAVE_FUNCTION_NAME (line 148) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 155) | inline
FILE: examples/libraries/cereal-1.3.0/include/cereal/archives/json.hpp
type cereal (line 35) | namespace cereal
type RapidJSONException (line 39) | struct RapidJSONException : Exception
method RapidJSONException (line 40) | RapidJSONException( const char * what_ ) : Exception( what_ ) {}
class JSONOutputArchive (line 106) | class JSONOutputArchive : public OutputArchive<JSONOutputArchive>, pub...
type NodeType (line 108) | enum class NodeType { StartObject, InObject, StartArray, InArray }
class Options (line 119) | class Options
method Options (line 123) | static Options Default(){ return Options(); }
method Options (line 126) | static Options NoIndent(){ return Options( JSONWriter::kDefaultMax...
type IndentChar (line 129) | enum class IndentChar : char
method Options (line 142) | explicit Options( int precision = JSONWriter::kDefaultMaxDecimalPl...
method JSONOutputArchive (line 160) | JSONOutputArchive(std::ostream & stream, Options const & options = O...
method saveBinaryValue (line 184) | void saveBinaryValue( const void * data, size_t size, const char * n...
method startNode (line 204) | void startNode()
method finishNode (line 212) | void finishNode()
method setNextName (line 240) | void setNextName( const char * name )
method saveValue (line 246) | void saveValue(bool b) { itsWriter.Bool(b); ...
method saveValue (line 248) | void saveValue(int i) { itsWriter.Int(i); ...
method saveValue (line 250) | void saveValue(unsigned u) { itsWriter.Uint(u); ...
method saveValue (line 252) | void saveValue(int64_t i64) { itsWriter.Int64(i64); ...
method saveValue (line 254) | void saveValue(uint64_t u64) { itsWriter.Uint64(u64); ...
method saveValue (line 256) | void saveValue(double d) { itsWriter.Double(d); ...
method saveValue (line 258) | void saveValue(std::string const & s) { itsWriter.String(s.c_str(), ...
method saveValue (line 260) | void saveValue(char const * s) { itsWriter.String(s); ...
method saveValue (line 262) | void saveValue(std::nullptr_t) { itsWriter.Null(); ...
method saveLong (line 270) | inline
method saveLong (line 275) | inline
method saveLong (line 280) | inline
method saveLong (line 285) | inline
method saveValue (line 291) | void saveValue( unsigned long lu ){ saveLong( lu ); }
method saveValue (line 296) | inline
method saveValue (line 302) | inline
method saveValue (line 313) | inline
method writeName (line 334) | void writeName()
method makeArray (line 366) | void makeArray()
class JSONInputArchive (line 419) | class JSONInputArchive : public InputArchive<JSONInputArchive>, public...
method JSONInputArchive (line 435) | JSONInputArchive(std::istream & stream) :
method loadBinaryValue (line 455) | void loadBinaryValue( void * data, size_t size, const char * name = ...
class Iterator (line 480) | class Iterator
method Iterator (line 483) | Iterator() : itsIndex( 0 ), itsType(Null_) {}
method Iterator (line 485) | Iterator(MemberIterator begin, MemberIterator end) :
method Iterator (line 492) | Iterator(ValueIterator begin, ValueIterator end) :
method Iterator (line 500) | Iterator & operator++()
method GenericValue (line 507) | GenericValue const & value()
method search (line 528) | inline void search( const char * searchName )
type Type (line 550) | enum Type {Value, Member, Null_}
method search (line 562) | inline void search()
method startNode (line 589) | void startNode()
method finishNode (line 600) | void finishNode()
method setNextName (line 614) | void setNextName( const char * name )
method loadValue (line 621) | inline
method loadValue (line 633) | inline
method loadValue (line 643) | void loadValue(bool & val) { search(); val = itsIteratorStack...
method loadValue (line 645) | void loadValue(int64_t & val) { search(); val = itsIteratorStack...
method loadValue (line 647) | void loadValue(uint64_t & val) { search(); val = itsIteratorStack...
method loadValue (line 649) | void loadValue(float & val) { search(); val = static_cast<floa...
method loadValue (line 651) | void loadValue(double & val) { search(); val = itsIteratorStack...
method loadValue (line 653) | void loadValue(std::string & val) { search(); val = itsIteratorStack...
method loadValue (line 655) | void loadValue(std::nullptr_t&) { search(); CEREAL_RAPIDJSON_ASSER...
method loadLong (line 662) | inline
method loadLong (line 667) | inline
method loadLong (line 672) | inline
method loadLong (line 677) | inline
method stringToNumber (line 699) | void stringToNumber( std::string const & str, long long & val ) { va...
method stringToNumber (line 701) | void stringToNumber( std::string const & str, unsigned long long & v...
method stringToNumber (line 703) | void stringToNumber( std::string const & str, long double & val ) { ...
method loadValue (line 713) | inline void loadValue(T & val)
method loadSize (line 721) | void loadSize(size_type & size)
function prologue (line 745) | inline
function prologue (line 750) | inline
function epilogue (line 757) | inline
function epilogue (line 763) | inline
function prologue (line 770) | inline
function prologue (line 775) | inline
function epilogue (line 782) | inline
function epilogue (line 788) | inline
function prologue (line 796) | inline
function prologue (line 803) | inline
function epilogue (line 810) | inline
function epilogue (line 815) | inline
function prologue (line 828) | inline void prologue( JSONOutputArchive & ar, T const & )
function prologue (line 837) | inline void prologue( JSONInputArchive & ar, T const & )
function epilogue (line 850) | inline void epilogue( JSONOutputArchive & ar, T const & )
function epilogue (line 859) | inline void epilogue( JSONInputArchive & ar, T const & )
function prologue (line 866) | inline
function prologue (line 873) | inline
function epilogue (line 879) | inline
function epilogue (line 884) | inline
function prologue (line 890) | inline
function prologue (line 897) | inline
function epilogue (line 903) | inline
function epilogue (line 908) | inline
function prologue (line 914) | inline
function prologue (line 921) | inline
function epilogue (line 927) | inline
function epilogue (line 932) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 940) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 947) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 955) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 962) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 969) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 976) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 983) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 990) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 998) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 1005) | inline
type cereal (line 76) | namespace cereal
type RapidJSONException (line 39) | struct RapidJSONException : Exception
method RapidJSONException (line 40) | RapidJSONException( const char * what_ ) : Exception( what_ ) {}
class JSONOutputArchive (line 106) | class JSONOutputArchive : public OutputArchive<JSONOutputArchive>, pub...
type NodeType (line 108) | enum class NodeType { StartObject, InObject, StartArray, InArray }
class Options (line 119) | class Options
method Options (line 123) | static Options Default(){ return Options(); }
method Options (line 126) | static Options NoIndent(){ return Options( JSONWriter::kDefaultMax...
type IndentChar (line 129) | enum class IndentChar : char
method Options (line 142) | explicit Options( int precision = JSONWriter::kDefaultMaxDecimalPl...
method JSONOutputArchive (line 160) | JSONOutputArchive(std::ostream & stream, Options const & options = O...
method saveBinaryValue (line 184) | void saveBinaryValue( const void * data, size_t size, const char * n...
method startNode (line 204) | void startNode()
method finishNode (line 212) | void finishNode()
method setNextName (line 240) | void setNextName( const char * name )
method saveValue (line 246) | void saveValue(bool b) { itsWriter.Bool(b); ...
method saveValue (line 248) | void saveValue(int i) { itsWriter.Int(i); ...
method saveValue (line 250) | void saveValue(unsigned u) { itsWriter.Uint(u); ...
method saveValue (line 252) | void saveValue(int64_t i64) { itsWriter.Int64(i64); ...
method saveValue (line 254) | void saveValue(uint64_t u64) { itsWriter.Uint64(u64); ...
method saveValue (line 256) | void saveValue(double d) { itsWriter.Double(d); ...
method saveValue (line 258) | void saveValue(std::string const & s) { itsWriter.String(s.c_str(), ...
method saveValue (line 260) | void saveValue(char const * s) { itsWriter.String(s); ...
method saveValue (line 262) | void saveValue(std::nullptr_t) { itsWriter.Null(); ...
method saveLong (line 270) | inline
method saveLong (line 275) | inline
method saveLong (line 280) | inline
method saveLong (line 285) | inline
method saveValue (line 291) | void saveValue( unsigned long lu ){ saveLong( lu ); }
method saveValue (line 296) | inline
method saveValue (line 302) | inline
method saveValue (line 313) | inline
method writeName (line 334) | void writeName()
method makeArray (line 366) | void makeArray()
class JSONInputArchive (line 419) | class JSONInputArchive : public InputArchive<JSONInputArchive>, public...
method JSONInputArchive (line 435) | JSONInputArchive(std::istream & stream) :
method loadBinaryValue (line 455) | void loadBinaryValue( void * data, size_t size, const char * name = ...
class Iterator (line 480) | class Iterator
method Iterator (line 483) | Iterator() : itsIndex( 0 ), itsType(Null_) {}
method Iterator (line 485) | Iterator(MemberIterator begin, MemberIterator end) :
method Iterator (line 492) | Iterator(ValueIterator begin, ValueIterator end) :
method Iterator (line 500) | Iterator & operator++()
method GenericValue (line 507) | GenericValue const & value()
method search (line 528) | inline void search( const char * searchName )
type Type (line 550) | enum Type {Value, Member, Null_}
method search (line 562) | inline void search()
method startNode (line 589) | void startNode()
method finishNode (line 600) | void finishNode()
method setNextName (line 614) | void setNextName( const char * name )
method loadValue (line 621) | inline
method loadValue (line 633) | inline
method loadValue (line 643) | void loadValue(bool & val) { search(); val = itsIteratorStack...
method loadValue (line 645) | void loadValue(int64_t & val) { search(); val = itsIteratorStack...
method loadValue (line 647) | void loadValue(uint64_t & val) { search(); val = itsIteratorStack...
method loadValue (line 649) | void loadValue(float & val) { search(); val = static_cast<floa...
method loadValue (line 651) | void loadValue(double & val) { search(); val = itsIteratorStack...
method loadValue (line 653) | void loadValue(std::string & val) { search(); val = itsIteratorStack...
method loadValue (line 655) | void loadValue(std::nullptr_t&) { search(); CEREAL_RAPIDJSON_ASSER...
method loadLong (line 662) | inline
method loadLong (line 667) | inline
method loadLong (line 672) | inline
method loadLong (line 677) | inline
method stringToNumber (line 699) | void stringToNumber( std::string const & str, long long & val ) { va...
method stringToNumber (line 701) | void stringToNumber( std::string const & str, unsigned long long & v...
method stringToNumber (line 703) | void stringToNumber( std::string const & str, long double & val ) { ...
method loadValue (line 713) | inline void loadValue(T & val)
method loadSize (line 721) | void loadSize(size_type & size)
function prologue (line 745) | inline
function prologue (line 750) | inline
function epilogue (line 757) | inline
function epilogue (line 763) | inline
function prologue (line 770) | inline
function prologue (line 775) | inline
function epilogue (line 782) | inline
function epilogue (line 788) | inline
function prologue (line 796) | inline
function prologue (line 803) | inline
function epilogue (line 810) | inline
function epilogue (line 815) | inline
function prologue (line 828) | inline void prologue( JSONOutputArchive & ar, T const & )
function prologue (line 837) | inline void prologue( JSONInputArchive & ar, T const & )
function epilogue (line 850) | inline void epilogue( JSONOutputArchive & ar, T const & )
function epilogue (line 859) | inline void epilogue( JSONInputArchive & ar, T const & )
function prologue (line 866) | inline
function prologue (line 873) | inline
function epilogue (line 879) | inline
function epilogue (line 884) | inline
function prologue (line 890) | inline
function prologue (line 897) | inline
function epilogue (line 903) | inline
function epilogue (line 908) | inline
function prologue (line 914) | inline
function prologue (line 921) | inline
function epilogue (line 927) | inline
function epilogue (line 932) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 940) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 947) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 955) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 962) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 969) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 976) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 983) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 990) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 998) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 1005) | inline
FILE: examples/libraries/cereal-1.3.0/include/cereal/archives/portable_binary.hpp
type cereal (line 36) | namespace cereal
type portable_binary_detail (line 38) | namespace portable_binary_detail
function is_little_endian (line 42) | inline std::uint8_t is_little_endian()
function swap_bytes (line 53) | inline void swap_bytes( std::uint8_t * data )
class PortableBinaryOutputArchive (line 78) | class PortableBinaryOutputArchive : public OutputArchive<PortableBinar...
class Options (line 82) | class Options
type Endianness (line 86) | enum class Endianness : std::uint8_t
method Options (line 90) | static Options Default(){ return Options(); }
method Options (line 93) | static Options LittleEndian(){ return Options( Endianness::little ...
method Options (line 96) | static Options BigEndian(){ return Options( Endianness::big ); }
method Options (line 100) | explicit Options( Endianness outputEndian = getEndianness() ) :
method Endianness (line 105) | inline static Endianness getEndianness()
method is_little_endian (line 109) | inline std::uint8_t is_little_endian() const
method PortableBinaryOutputArchive (line 120) | PortableBinaryOutputArchive(std::ostream & stream, Options const & o...
method saveBinary (line 131) | inline
class PortableBinaryInputArchive (line 180) | class PortableBinaryInputArchive : public InputArchive<PortableBinaryI...
class Options (line 184) | class Options
type Endianness (line 188) | enum class Endianness : std::uint8_t
method Options (line 192) | static Options Default(){ return Options(); }
method Options (line 195) | static Options LittleEndian(){ return Options( Endianness::little ...
method Options (line 198) | static Options BigEndian(){ return Options( Endianness::big ); }
method Options (line 202) | explicit Options( Endianness inputEndian = getEndianness() ) :
method Endianness (line 207) | inline static Endianness getEndianness()
method is_little_endian (line 211) | inline std::uint8_t is_little_endian() const
method PortableBinaryInputArchive (line 222) | PortableBinaryInputArchive(std::istream & stream, Options const & op...
method loadBinary (line 238) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 265) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 276) | inline
function CEREAL_SERIALIZE_FUNCTION_NAME (line 289) | CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, NameValuePair<T> & t )
function CEREAL_SERIALIZE_FUNCTION_NAME (line 297) | CEREAL_SERIALIZE_FUNCTION_NAME( Archive & ar, SizeTag<T> & t )
function CEREAL_SAVE_FUNCTION_NAME (line 303) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 315) | inline
FILE: examples/libraries/cereal-1.3.0/include/cereal/archives/xml.hpp
type cereal (line 46) | namespace cereal
type xml_detail (line 48) | namespace xml_detail
function isWhitespace (line 61) | inline bool isWhitespace( char c )
class XMLOutputArchive (line 96) | class XMLOutputArchive : public OutputArchive<XMLOutputArchive>, publi...
class Options (line 106) | class Options
method Options (line 110) | static Options Default(){ return Options(); }
method Options (line 117) | explicit Options( int precision_ = std::numeric_limits<double>::ma...
method Options (line 140) | Options & precision( int value ){ itsPrecision = value; return * t...
method Options (line 142) | Options & indent( bool enable ){ itsIndent = enable; return *this; }
method Options (line 144) | Options & outputType( bool enable ){ itsOutputType = enable; retur...
method Options (line 146) | Options & sizeAttributes( bool enable ){ itsSizeAttributes = enabl...
method XMLOutputArchive (line 163) | XMLOutputArchive( std::ostream & stream, Options const & options = O...
method saveBinaryValue (line 200) | void saveBinaryValue( const void * data, size_t size, const char * n...
method startNode (line 227) | void startNode()
method finishNode (line 242) | void finishNode()
method setNextName (line 248) | void setNextName( const char * name )
method saveValue (line 257) | inline
method saveValue (line 285) | void saveValue( uint8_t const & value )
method saveValue (line 291) | void saveValue( int8_t const & value )
method insertType (line 297) | inline
method appendAttribute (line 313) | void appendAttribute( const char * name, const char * value )
method hasSizeAttributes (line 320) | bool hasSizeAttributes() const { return itsSizeAttributes; }
type NodeInfo (line 324) | struct NodeInfo
method NodeInfo (line 326) | NodeInfo( rapidxml::xml_node<> * n = nullptr,
method getValueName (line 341) | std::string getValueName()
class XMLInputArchive (line 405) | class XMLInputArchive : public InputArchive<XMLInputArchive>, public t...
method XMLInputArchive (line 417) | XMLInputArchive( std::istream & stream ) :
method loadBinaryValue (line 454) | void loadBinaryValue( void * data, size_t size, const char * name = ...
method startNode (line 488) | void startNode()
method finishNode (line 508) | void finishNode()
method setNextName (line 528) | void setNextName( const char * name )
method loadValue (line 535) | inline
method loadValue (line 546) | inline
method loadValue (line 553) | void loadValue( int8_t & value )
method loadValue (line 559) | void loadValue( uint8_t & value )
method loadValue (line 569) | inline
method loadValue (line 578) | traits::sfinae> inline
method loadValue (line 587) | inline
method loadValue (line 596) | inline
method loadValue (line 605) | inline
method loadValue (line 612) | void loadValue( float & value )
method loadValue (line 629) | void loadValue( double & value )
method loadValue (line 646) | void loadValue( long double & value )
method loadValue (line 663) | inline
method loadSize (line 673) | inline
method getNumChildren (line 681) | static size_t getNumChildren( rapidxml::xml_node<> * node )
type NodeInfo (line 698) | struct NodeInfo
method NodeInfo (line 700) | NodeInfo( rapidxml::xml_node<> * n = nullptr ) :
method advance (line 709) | void advance()
function prologue (line 771) | inline
function prologue (line 776) | inline
function epilogue (line 783) | inline
function epilogue (line 788) | inline
function prologue (line 795) | inline
function prologue (line 800) | inline
function epilogue (line 807) | inline
function epilogue (line 813) | inline
function prologue (line 820) | inline
function prologue (line 829) | inline
function epilogue (line 835) | inline
function epilogue (line 839) | inline
function prologue (line 850) | inline
function prologue (line 859) | inline
function epilogue (line 871) | inline
function epilogue (line 879) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 890) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 898) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 907) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 912) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 920) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 927) | inline
function CEREAL_SAVE_FUNCTION_NAME (line 935) | inline
function CEREAL_LOAD_FUNCTION_NAME (line 942) | inline
FILE: examples/libraries/cereal-1.3.0/include/cereal/cereal.hpp
type cereal (line 48) | namespace cereal
function make_nvp (line 54) | inline
function make_nvp (line 63) | inline
function binary_data (line 80) | inline
function make_size_tag (line 95) | inline
function defer (line 148) | inline
function prologue (line 161) | inline
function epilogue (line 168) | inline
type Flags (line 185) | enum Flags { AllowEmptyClassElision = 1 }
class OutputArchive (line 296) | class OutputArchive : public detail::OutputArchiveBase
method OutputArchive (line 301) | OutputArchive(ArchiveType * const derived) : self(derived), itsCurrent...
method OutputArchive (line 304) | OutputArchive & operator=( OutputArchive const & ) = delete;
method ArchiveType (line 308) | inline
method serializeDeferments (line 317) | void serializeDeferments()
method ArchiveType (line 346) | inline
method ArchiveType (line 357) | inline
method registerSharedPointer (line 374) | inline std::uint32_t registerSharedPointer( void const * addr )
method registerPolymorphicType (line 398) | inline std::uint32_t registerPolymorphicType( char const * name )
method process (line 413) | inline
method process (line 422) | inline
method ArchiveType (line 431) | inline
method ArchiveType (line 445) | inline
method ArchiveType (line 454) | inline
method ArchiveType (line 478) | inline
method ArchiveType (line 486) | inline
method ArchiveType (line 494) | inline
method ArchiveType (line 502) | inline
method ArchiveType (line 510) | inline
method ArchiveType (line 518) | inline
method ArchiveType (line 528) | inline
method ArchiveType (line 540) | inline
method registerClassVersion (line 568) | inline
method ArchiveType (line 585) | inline
method ArchiveType (line 594) | inline
method ArchiveType (line 603) | inline
method ArchiveType (line 612) | inline
method ArchiveType (line 621) | inline
method ArchiveType (line 630) | inline
class InputArchive (line 679) | class InputArchive : public detail::InputArchiveBase
method InputArchive (line 684) | InputArchive(ArchiveType * const derived) :
method InputArchive (line 692) | InputArchive & operator=( InputArchive const & ) = delete;
method ArchiveType (line 696) | inline
method serializeDeferments (line 705) | void serializeDeferments()
method ArchiveType (line 734) | inline
method ArchiveType (line 745) | inline
method getSharedPointer (line 762) | inline std::shared_ptr<void> getSharedPointer(std::uint32_t const id)
method registerSharedPointer (line 780) | inline void registerSharedPointer(std::uint32_t const id, std::shared_...
method getPolymorphicName (line 793) | inline std::string getPolymorphicName(std::uint32_t const id)
method registerPolymorphicName (line 810) | inline void registerPolymorphicName(std::uint32_t const id, std::strin...
method process (line 818) | inline
method process (line 827) | inline
method ArchiveType (line 836) | inline
method ArchiveType (line 850) | inline
method ArchiveType (line 859) | inline
method ArchiveType (line 883) | inline
method ArchiveType (line 891) | inline
method ArchiveType (line 899) | inline
method ArchiveType (line 907) | inline
method ArchiveType (line 915) | inline
method ArchiveType (line 926) | inline
method ArchiveType (line 939) | inline
method ArchiveType (line 951) | inline
method loadClassVersion (line 982) | inline
method ArchiveType (line 1003) | inline
method ArchiveType (line 1013) | inline
method ArchiveType (line 1023) | inline
method ArchiveType (line 1033) | inline
method ArchiveType (line 1043) | inline
method ArchiveType (line 1056) | inline
FILE: examples/libraries/cereal-1.3.0/include/cereal/details/helpers.hpp
type cereal (line 43) | namespace cereal
type Exception (line 48) | struct Exception : public std::runtime_error
method Exception (line 50) | explicit Exception( const std::string & what_ ) : std::runtime_error...
method Exception (line 51) | explicit Exception( const char * what_ ) : std::runtime_error(what_) {}
class BinaryOutputArchive (line 64) | class BinaryOutputArchive
class BinaryInputArchive (line 65) | class BinaryInputArchive
type detail (line 68) | namespace detail
type NameValuePairCore (line 70) | struct NameValuePairCore {}
type DeferredDataCore (line 71) | struct DeferredDataCore {}
class OutputArchiveBase (line 269) | class OutputArchiveBase
method OutputArchiveBase (line 272) | OutputArchiveBase() = default;
method OutputArchiveBase (line 273) | OutputArchiveBase( OutputArchiveBase && ) CEREAL_NOEXCEPT {}
method OutputArchiveBase (line 274) | OutputArchiveBase & operator=( OutputArchiveBase && ) CEREAL_NOEXC...
method rtti (line 278) | virtual void rtti() {}
class InputArchiveBase (line 281) | class InputArchiveBase
method InputArchiveBase (line 284) | InputArchiveBase() = default;
method InputArchiveBase (line 285) | InputArchiveBase( InputArchiveBase && ) CEREAL_NOEXCEPT {}
method InputArchiveBase (line 286) | InputArchiveBase & operator=( InputArchiveBase && ) CEREAL_NOEXCEP...
method rtti (line 290) | virtual void rtti() {}
type polymorphic_serialization_support (line 294) | struct polymorphic_serialization_support
type adl_tag (line 295) | struct adl_tag
type version_binding_tag (line 395) | struct version_binding_tag {}
type Version (line 401) | struct Version
type Versions (line 409) | struct Versions
method find (line 413) | std::uint32_t find( std::size_t hash, std::uint32_t version )
class NameValuePair (line 139) | class NameValuePair : detail::NameValuePairCore
method NameValuePair (line 154) | NameValuePair & operator=( NameValuePair const & ) = delete;
method NameValuePair (line 165) | NameValuePair( char const * n, T && v ) : name(n), value(std::forwar...
function make_nvp (line 174) | inline
function make_nvp (line 187) | inline
type BinaryData (line 211) | struct BinaryData
method BinaryData (line 219) | BinaryData( T && d, uint64_t s ) : data(std::forward<T>(d)), size(s) {}
class DeferredData (line 232) | class DeferredData : detail::DeferredDataCore
method DeferredData (line 247) | DeferredData & operator=( DeferredData const & ) = delete;
method DeferredData (line 257) | DeferredData( T && v ) : value(std::forward<T>(v)) {}
type detail (line 263) | namespace detail
type NameValuePairCore (line 70) | struct NameValuePairCore {}
type DeferredDataCore (line 71) | struct DeferredDataCore {}
class OutputArchiveBase (line 269) | class OutputArchiveBase
method OutputArchiveBase (line 272) | OutputArchiveBase() = default;
method OutputArchiveBase (line 273) | OutputArchiveBase( OutputArchiveBase && ) CEREAL_NOEXCEPT {}
method OutputArchiveBase (line 274) | OutputArchiveBase & operator=( OutputArchiveBase && ) CEREAL_NOEXC...
method rtti (line 278) | virtual void rtti() {}
class InputArchiveBase (line 281) | class InputArchiveBase
method InputArchiveBase (line 284) | InputArchiveBase() = default;
method InputArchiveBase (line 285) | InputArchiveBase( InputArchiveBase && ) CEREAL_NOEXCEPT {}
method InputArchiveBase (line 286) | InputArchiveBase & operator=( InputArchiveBase && ) CEREAL_NOEXCEP...
method rtti (line 290) | virtual void rtti() {}
type polymorphic_serialization_support (line 294) | struct polymorphic_serialization_support
type adl_tag (line 295) | struct adl_tag
type version_binding_tag (line 395) | struct version_binding_tag {}
type Version (line 401) | struct Version
type Versions (line 409) | struct Versions
method find (line 413) | std::uint32_t find( std::size_t hash, std::uint32_t version )
class SizeTag (line 312) | class SizeTag
method SizeTag (line 321) | SizeTag & operator=( SizeTag const & ) = delete;
method SizeTag (line 324) | SizeTag( T && sz ) : size(std::forward<T>(sz)) {}
type MapItem (line 351) | struct MapItem
method MapItem (line 365) | MapItem( Key && key_, Value && value_ ) : key(std::forward<Key>(key_...
method MapItem (line 367) | MapItem & operator=( MapItem const & ) = delete;
method CEREAL_SERIALIZE_FUNCTION_NAME (line 373) | inline
function make_map_item (line 384) | inline
type detail (line 390) | namespace detail
type NameValuePairCore (line 70) | struct NameValuePairCore {}
type DeferredDataCore (line 71) | struct DeferredDataCore {}
class OutputArchiveBase (line 269) | class OutputArchiveBase
method OutputArchiveBase (line 272) | OutputArchiveBase() = default;
method OutputArchiveBase (line 273) | OutputArchiveBase( OutputArchiveBase && ) CEREAL_NOEXCEPT {}
method OutputArchiveBase (line 274) | OutputArchiveBase & operator=( OutputArchiveBase && ) CEREAL_NOEXC...
method rtti (line 278) | virtual void rtti() {}
class InputArchiveBase (line 281) | class InputArchiveBase
method InputArchiveBase (line 284) | InputArchiveBase() = default;
method InputArchiveBase (line 285) | InputArchiveBase( InputArchiveBase && ) CEREAL_NOEXCEPT {}
method InputArchiveBase (line 286) | InputArchiveBase & operator=( InputArchiveBase && ) CEREAL_NOEXCEP...
method rtti (line 290) | virtual void rtti() {}
type polymorphic_serialization_support (line 294) | struct polymorphic_serialization_support
type adl_tag (line 295) | struct adl_tag
type version_binding_tag (line 395) | struct version_binding_tag {}
type Version (line 401) | struct Version
type Versions (line 409) | struct Versions
method find (line 413) | std::uint32_t find( std::size_t hash, std::uint32_t version )
FILE: examples/libraries/cereal-1.3.0/include/cereal/details/polymorphic_impl.hpp
type cereal (line 86) | namespace cereal
type detail (line 89) | namespace detail
type PolymorphicCaster (line 104) | struct PolymorphicCaster
method PolymorphicCaster (line 106) | PolymorphicCaster() = default;
method PolymorphicCaster (line 107) | PolymorphicCaster( const PolymorphicCaster & ) = default;
method PolymorphicCaster (line 108) | PolymorphicCaster & operator=( const PolymorphicCaster & ) = default;
method PolymorphicCaster (line 109) | PolymorphicCaster( PolymorphicCaster && ) CEREAL_NOEXCEPT {}
method PolymorphicCaster (line 110) | PolymorphicCaster & operator=( PolymorphicCaster && ) CEREAL_NOEXC...
type PolymorphicCasters (line 124) | struct PolymorphicCasters
method lookup_if_exists (line 144) | static std::pair<bool, std::vector<PolymorphicCaster const *> cons...
method Derived (line 186) | inline
method upcast (line 213) | inline
type PolymorphicVirtualCaster (line 238) | struct PolymorphicVirtualCaster : PolymorphicCaster
method PolymorphicVirtualCaster (line 244) | PolymorphicVirtualCaster()
method upcast (line 409) | std::shared_ptr<void> upcast( std::shared_ptr<void> const & ptr ) ...
type RegisterPolymorphicCaster (line 423) | struct RegisterPolymorphicCaster
method PolymorphicCaster (line 425) | static PolymorphicCaster const * bind( std::true_type /* is_polymo...
method PolymorphicCaster (line 430) | static PolymorphicCaster const * bind( std::false_type /* is_polym...
method PolymorphicCaster (line 435) | static PolymorphicCaster const * bind()
type binding_name (line 445) | struct binding_name {}
type OutputBindingMap (line 453) | struct OutputBindingMap
type Serializers (line 464) | struct Serializers
type EmptyDeleter (line 475) | struct EmptyDeleter { void operator()(T *) const {} }
type InputBindingMap (line 483) | struct InputBindingMap
type Serializers (line 496) | struct Serializers
class InputArchiveBase (line 507) | class InputArchiveBase
class OutputArchiveBase (line 508) | class OutputArchiveBase
type InputBindingCreator (line 515) | struct InputBindingCreator
method InputBindingCreator (line 518) | InputBindingCreator()
type OutputBindingCreator (line 561) | struct OutputBindingCreator
method writeMetadata (line 564) | static void writeMetadata(Archive & ar)
class PolymorphicSharedPointerWrapper (line 582) | class PolymorphicSharedPointerWrapper
method PolymorphicSharedPointerWrapper (line 597) | PolymorphicSharedPointerWrapper( T const * dptr ) : refCount(), ...
method savePolymorphicSharedPtr (line 616) | static inline void savePolymorphicSharedPtr( Archive & ar, T const...
method savePolymorphicSharedPtr (line 631) | static inline void savePolymorphicSharedPtr( Archive & ar, T const...
method OutputBindingCreator (line 638) | OutputBindingCreator()
type adl_tag (line 681) | struct adl_tag {}
type polymorphic_binding_tag (line 685) | struct polymorphic_binding_tag {}
type create_bindings (line 689) | struct create_bindings
method load (line 703) | inline static void load(std::false_type) {}
method save (line 704) | inline static void save(std::false_type) {}
type instantiate_function (line 709) | struct instantiate_function {}
type polymorphic_serialization_support (line 717) | struct polymorphic_serialization_support
function CEREAL_DLL_EXPORT (line 734) | CEREAL_DLL_EXPORT void polymorphic_serialization_support<Archive,T>:...
type bind_to_archives (line 751) | struct bind_to_archives
method bind (line 754) | void bind(std::false_type) const
method bind (line 760) | void bind(std::true_type) const
method bind_to_archives (line 766) | bind_to_archives const & bind() const
type init_binding (line 777) | struct init_binding
function instantiate_polymorphic_binding (line 792) | void instantiate_polymorphic_binding( T*, int, BindingTag, adl_tag ) {}
type detail (line 441) | namespace detail
type PolymorphicCaster (line 104) | struct PolymorphicCaster
method PolymorphicCaster (line 106) | PolymorphicCaster() = default;
method PolymorphicCaster (line 107) | PolymorphicCaster( const PolymorphicCaster & ) = default;
method PolymorphicCaster (line 108) | PolymorphicCaster & operator=( const PolymorphicCaster & ) = default;
method PolymorphicCaster (line 109) | PolymorphicCaster( PolymorphicCaster && ) CEREAL_NOEXCEPT {}
method PolymorphicCaster (line 110) | PolymorphicCaster & operator=( PolymorphicCaster && ) CEREAL_NOEXC...
type PolymorphicCasters (line 124) | struct PolymorphicCasters
method lookup_if_exists (line 144) | static std::pair<bool, std::vector<PolymorphicCaster const *> cons...
method Derived (line 186) | inline
method upcast (line 213) | inline
type PolymorphicVirtualCaster (line 238) | struct PolymorphicVirtualCaster : PolymorphicCaster
method PolymorphicVirtualCaster (line 244) | PolymorphicVirtualCaster()
method upcast (line 409) | std::shared_ptr<void> upcast( std::shared_ptr<void> const & ptr ) ...
type RegisterPolymorphicCaster (line 423) | struct RegisterPolymorphicCaster
method PolymorphicCaster (line 425) | static PolymorphicCaster const * bind( std::true_type /* is_polymo...
method PolymorphicCaster (line 430) | static PolymorphicCaster const * bind( std::false_type /* is_polym...
method PolymorphicCaster (line 435) | static PolymorphicCaster const * bind()
type binding_name (line 445) | struct binding_name {}
type OutputBindingMap (line 453) | struct OutputBindingMap
type Serializers (line 464) | struct Serializers
type EmptyDeleter (line 475) | struct EmptyDeleter { void operator()(T *) const {} }
type InputBindingMap (line 483) | struct InputBindingMap
type Serializers (line 496) | struct Serializers
class InputArchiveBase (line 507) | class InputArchiveBase
class OutputArchiveBase (line 508) | class OutputArchiveBase
type InputBindingCreator (line 515) | struct InputBindingCreator
method InputBindingCreator (line 518) | InputBindingCreator()
type OutputBindingCreator (line 561) | struct OutputBindingCreator
method writeMetadata (line 564) | static void writeMetadata(Archive & ar)
class PolymorphicSharedPointerWrapper (line 582) | class PolymorphicSharedPointerWrapper
method PolymorphicSharedPointerWrapper (line 597) | PolymorphicSharedPointerWrapper( T const * dptr ) : refCount(), ...
method savePolymorphicSharedPtr (line 616) | static inline void savePolymorphicSharedPtr( Archive & ar, T const...
method savePolymorphicSharedPtr (line 631) | static inline void savePolymorphicSharedPtr( Archive & ar, T const...
method OutputBindingCreator (line 638) | OutputBindingCreator()
type adl_tag (line 681) | struct adl_tag {}
type polymorphic_binding_tag (line 685) | struct polymorphic_binding_tag {}
type create_bindings (line 689) | struct create_bindings
method load (line 703) | inline static void load(std::false_type) {}
method save (line 704) | inline static void save(std::false_type) {}
type instantiate_function (line 709) | struct instantiate_function {}
type polymorphic_serialization_support (line 717) | struct polymorphic_serialization_support
function CEREAL_DLL_EXPORT (line 734) | CEREAL_DLL_EXPORT void polymorphic_serialization_support<Archive,T>:...
type bind_to_archives (line 751) | struct bind_to_archives
method bind (line 754) | void bind(std::false_type) const
method bind (line 760) | void bind(std::true_type) const
method bind_to_archives (line 766) | bind_to_archives const & bind() const
type init_binding (line 777) | struct init_binding
function instantiate_polymorphic_binding (line 792) | void instantiate_polymorphic_binding( T*, int, BindingTag, adl_tag ) {}
FILE: examples/libraries/cereal-1.3.0/include/cereal/details/polymorphic_impl_fwd.hpp
type cereal (line 48) | namespace cereal
type detail (line 50) | namespace detail
type RegisterPolymorphicCaster (line 54) | struct RegisterPolymorphicCaster
type PolymorphicCasters (line 57) | struct PolymorphicCasters
type PolymorphicRelation (line 61) | struct PolymorphicRelation
FILE: examples/libraries/cereal-1.3.0/include/cereal/details/static_object.hpp
type detail (line 57) | namespace detail
function StaticObject (line 67) | class CEREAL_DLL_EXPORT StaticObject
FILE: examples/libraries/cereal-1.3.0/include/cereal/details/traits.hpp
type cereal (line 45) | namespace cereal
type traits (line 47) | namespace traits
type detail (line 52) | namespace detail
type delay_static_assert (line 57) | struct delay_static_assert : std::false_type {}
type Void (line 62) | struct Void { typedef void type; }
type sfinae (line 66) | enum class sfinae {}
type meta_bool_and (line 70) | struct meta_bool_and : std::integral_constant<bool, H && meta_bool...
type meta_bool_and<B> (line 71) | struct meta_bool_and<B> : std::integral_constant<bool, B> {}
type meta_bool_or (line 73) | struct meta_bool_or : std::integral_constant<bool, H || meta_bool_...
type meta_bool_or<B> (line 74) | struct meta_bool_or<B> : std::integral_constant<bool, B> {}
type EnableIfHelper (line 79) | struct EnableIfHelper : std::enable_if<meta_bool_and<Conditions......
type DisableIfHelper (line 82) | struct DisableIfHelper : std::enable_if<!meta_bool_or<Conditions.....
type get_output_from_input (line 154) | struct get_output_from_input : no
type get_input_from_output (line 161) | struct get_input_from_output : no
type detail (line 151) | namespace detail
type delay_static_assert (line 57) | struct delay_static_assert : std::false_type {}
type Void (line 62) | struct Void { typedef void type; }
type sfinae (line 66) | enum class sfinae {}
type meta_bool_and (line 70) | struct meta_bool_and : std::integral_constant<bool, H && meta_bool...
type meta_bool_and<B> (line 71) | struct meta_bool_and<B> : std::integral_constant<bool, B> {}
type meta_bool_or (line 73) | struct meta_bool_or : std::integral_constant<bool, H || meta_bool_...
type meta_bool_or<B> (line 74) | struct meta_bool_or<B> : std::integral_constant<bool, B> {}
type EnableIfHelper (line 79) | struct EnableIfHelper : std::enable_if<meta_bool_and<Conditions......
type DisableIfHelper (line 82) | struct DisableIfHelper : std::enable_if<!meta_bool_or<Conditions.....
type get_output_from_input (line 154) | struct get_output_from_input : no
type get_input_from_output (line 161) | struct get_input_from_output : no
type has_member_ (line 210) | struct has_member_
type has_non_member_ (line 231) | struct has_non_member_
type has_member_versioned_save (line 340) | struct has_member_versioned_save : std::integral_constant<bool, deta...
type has_non_member_ (line 381) | struct has_non_member_
type has_non_member_ (line 576) | struct has_non_member_
class Dest (line 622) | class Dest
type NoConvertRef (line 636) | struct NoConvertRef : NoConvertBase
type AnyConvert (line 654) | struct AnyConvert
type has_non_member_ (line 866) | struct has_non_member_
type has_member_versioned_load_and_construct (line 903) | struct has_member_versioned_load_and_construct : detail::has_member_ve...
type has_non_member_ (line 925) | struct has_non_member_
type has_member_split (line 953) | struct has_member_split : std::integral_constant<bool,
type has_non_member_split (line 959) | struct has_non_member_split : std::integral_constant<bool,
type has_invalid_output_versioning (line 965) | struct has_invalid_output_versioning : std::integral_constant<bool,
type has_invalid_input_versioning (line 975) | struct has_invalid_input_versioning : std::integral_constant<bool,
type detail (line 984) | namespace detail
type count_specializations (line 1003) | struct count_specializations : std::integral_constant<int,
type count_output_serializers (line 1093) | struct count_output_serializers : std::integral_constant<int,
type count_input_serializers (line 1120) | struct count_input_serializers : std::integral_constant<int,
type base_class_id (line 1145) | struct base_class_id
method base_class_id (line 1148) | base_class_id(T const * const t) :
type base_class_id_hash (line 1161) | struct base_class_id_hash { size_t operator()(base_class_id const & ...
type BaseCastBase (line 1167) | struct BaseCastBase {}
type get_base_class (line 1170) | struct get_base_class
type get_base_class<Cast<Base>> (line 1173) | struct get_base_class<Cast<Base>>
type has_minimal_base_class_serialization_impl (line 1181) | struct has_minimal_base_class_serialization_impl : Test<typename get...
type has_minimal_base_class_serialization_impl<Cast,Test, Archive, false> (line 1186) | struct has_minimal_base_class_serialization_impl<Cast,Test, Archive,...
type shared_from_this_wrapper (line 1202) | struct shared_from_this_wrapper
type is_specialized (line 1014) | struct is_specialized : std::integral_constant<bool,
type has_minimal_output_serialization (line 1066) | struct has_minimal_output_serialization : std::integral_constant<bool,
type has_minimal_input_serialization (line 1078) | struct has_minimal_input_serialization : std::integral_constant<bool,
type detail (line 1088) | namespace detail
type count_specializations (line 1003) | struct count_specializations : std::integral_constant<int,
type count_output_serializers (line 1093) | struct count_output_serializers : std::integral_constant<int,
type count_input_serializers (line 1120) | struct count_input_serializers : std::integral_constant<int,
type base_class_id (line 1145) | struct base_class_id
method base_class_id (line 1148) | base_class_id(T const * const t) :
type base_class_id_hash (line 1161) | struct base_class_id_hash { size_t operator()(base_class_id const & ...
type BaseCastBase (line 1167) | struct BaseCastBase {}
type get_base_class (line 1170) | struct get_base_class
type get_base_class<Cast<Base>> (line 1173) | struct get_base_class<Cast<Base>>
type has_minimal_base_class_serialization_impl (line 1181) | struct has_minimal_base_class_serialization_impl : Test<typename get...
type has_minimal_base_class_serialization_impl<Cast,Test, Archive, false> (line 1186) | struct has_minimal_base_class_serialization_impl<Cast,Test, Archive,...
type shared_from_this_wrapper (line 1202) | struct shared_from_this_wrapper
type is_output_serializable (line 1111) | struct is_output_serializable : std::integral_constant<bool,
type detail (line 1115) | namespace detail
type count_specializations (line 1003) | struct count_specializations : std::integral_constant<int,
type count_output_serializers (line 1093) | struct count_output_serializers : std::integral_constant<int,
type count_input_serializers (line 1120) | struct count_input_serializers : std::integral_constant<int,
type base_class_id (line 1145) | struct base_class_id
method base_class_id (line 1148) | base_class_id(T const * const t) :
type base_class_id_hash (line 1161) | struct base_class_id_hash { size_t operator()(base_class_id const & ...
type BaseCastBase (line 1167) | struct BaseCastBase {}
type get_base_class (line 1170) | struct get_base_class
type get_base_class<Cast<Base>> (line 1173) | struct get_base_class<Cast<Base>>
type has_minimal_base_class_serialization_impl (line 1181) | struct has_minimal_base_class_serialization_impl : Test<typename get...
type has_minimal_base_class_serialization_impl<Cast,Test, Archive, false> (line 1186) | struct has_minimal_base_class_serialization_impl<Cast,Test, Archive,...
type shared_from_this_wrapper (line 1202) | struct shared_from_this_wrapper
type is_input_serializable (line 1138) | struct is_input_serializable : std::integral_constant<bool,
type detail (line 1143) | namespace detail
type count_specializations (line 1003) | struct count_specializations : std::integral_constant<int,
type count_output_serializers (line 1093) | struct count_output_serializers : std::integral_constant<int,
type count_input_serializers (line 1120) | struct count_input_serializers : std::integral_constant<int,
type base_class_id (line 1145) | struct base_class_id
method base_class_id (line 1148) | base_class_id(T const * const t) :
type base_class_id_hash (line 1161) | struct base_class_id_hash { size_t operator()(base_class_id const & ...
type BaseCastBase (line 1167) | struct BaseCastBase {}
type get_base_class (line 1170) | struct get_base_class
type get_base_class<Cast<Base>> (line 1173) | struct get_base_class<Cast<Base>>
type has_minimal_base_class_serialization_impl (line 1181) | struct has_minimal_base_class_serialization_impl : Test<typename get...
type has_minimal_base_class_serialization_impl<Cast,Test, Archive, false> (line 1186) | struct has_minimal_base_class_serialization_impl<Cast,Test, Archive,...
type shared_from_this_wrapper (line 1202) | struct shared_from_this_wrapper
type detail (line 1164) | namespace detail
type count_specializations (line 1003) | struct count_specializations : std::integral_constant<int,
type count_output_serializers (line 1093) | struct count_output_serializers : std::integral_constant<int,
type count_input_serializers (line 1120) | struct count_input_serializers : std::integral_constant<int,
type base_class_id (line 1145) | struct base_class_id
method base_class_id (line 1148) | base_class_id(T const * const t) :
type base_class_id_hash (line 1161) | struct base_class_id_hash { size_t operator()(base_class_id const & ...
type BaseCastBase (line 1167) | struct BaseCastBase {}
type get_base_class (line 1170) | struct get_base_class
type get_base_class<Cast<Base>> (line 1173) | struct get_base_class<Cast<Base>>
type has_minimal_base_class_serialization_impl (line 1181) | struct has_minimal_base_class_serialization_impl : Test<typename get...
type has_minimal_base_class_serialization_impl<Cast,Test, Archive, false> (line 1186) | struct has_minimal_base_class_serialization_impl<Cast,Test, Archive,...
type shared_from_this_wrapper (line 1202) | struct shared_from_this_wrapper
type has_minimal_base_class_serialization (line 1195) | struct has_minimal_base_class_serialization : detail::has_minimal_base...
type detail (line 1200) | namespace detail
type count_specializations (line 1003) | struct count_specializations : std::integral_constant<int,
type count_output_serializers (line 1093) | struct count_output_serializers : std::integral_constant<int,
type count_input_serializers (line 1120) | struct count_input_serializers : std::integral_constant<int,
type base_class_id (line 1145) | struct base_class_id
method base_class_id (line 1148) | base_class_id(T const * const t) :
type base_class_id_hash (line 1161) | struct base_class_id_hash { size_t operator()(base_class_id const & ...
type BaseCastBase (line 1167) | struct BaseCastBase {}
type get_base_class (line 1170) | struct get_base_class
type get_base_class<Cast<Base>> (line 1173) | struct get_base_class<Cast<Base>>
type has_minimal_base_class_serialization_impl (line 1181) | struct has_minimal_base_class_serialization_impl : Test<typename get...
type has_minimal_base_class_serialization_impl<Cast,Test, Archive, false> (line 1186) | struct has_minimal_base_class_serialization_impl<Cast,Test, Archive,...
type shared_from_this_wrapper (line 1202) | struct shared_from_this_wrapper
type has_shared_from_this (line 1216) | struct has_shared_from_this : decltype((detail::shared_from_this_wrapp...
type get_shared_from_this_base (line 1221) | struct get_shared_from_this_base
type strip_minimal (line 1239) | struct strip_minimal
type strip_minimal<T, true> (line 1246) | struct strip_minimal<T, true>
type is_default_constructible (line 1254) | struct is_default_constructible
type test (line 1258) | struct test : no {}
type test<TT, typename detail::Void< decltype( cereal::access::construct<TT>() ) >::type> (line 1260) | struct test<TT, typename detail::Void< decltype( cereal::access::con...
type detail (line 1272) | namespace detail
type count_specializations (line 1003) | struct count_specializations : std::integral_constant<int,
type count_output_serializers (line 1093) | struct count_output_serializers : std::integral_constant<int,
type count_input_serializers (line 1120) | struct count_input_serializers : std::integral_constant<int,
type base_class_id (line 1145) | struct base_class_id
method base_class_id (line 1148) | base_class_id(T const * const t) :
type base_class_id_hash (line 1161) | struct base_class_id_hash { size_t operator()(base_class_id const & ...
type BaseCastBase (line 1167) | struct BaseCastBase {}
type get_base_class (line 1170) | struct get_base_class
type get_base_class<Cast<Base>> (line 1173) | struct get_base_class<Cast<Base>>
type has_minimal_base_class_serialization_impl (line 1181) | struct has_minimal_base_class_serialization_impl : Test<typename get...
type has_minimal_base_class_serialization_impl<Cast,Test, Archive, false> (line 1186) | struct has_minimal_base_class_serialization_impl<Cast,Test, Archive,...
type shared_from_this_wrapper (line 1202) | struct shared_from_this_wrapper
type is_same_archive (line 1290) | struct is_same_archive : std::integral_constant<bool,
type TextArchive (line 1321) | struct TextArchive {}
type is_text_archive (line 1325) | struct is_text_archive : std::integral_constant<bool,
type detail (line 1331) | namespace detail
type Construct (line 1338) | struct Construct
method T (line 1344) | static T * load_andor_construct( A & /*ar*/, construct<T> & /*constr...
type Construct<T, A, false, false, false, false> (line 1350) | struct Construct<T, A, false, false, false, false>
method T (line 1363) | static T * load_andor_construct()
type Construct<T, A, true, false, false, false> (line 1369) | struct Construct<T, A, true, false, false, false>
method load_andor_construct (line 1371) | static void load_andor_construct( A & ar, construct<T> & construct )
type Construct<T, A, false, true, false, false> (line 1379) | struct Construct<T, A, false, true, false, false>
method load_andor_construct (line 1381) | static void load_andor_construct( A & ar, construct<T> & construct )
type Construct<T, A, false, false, true, false> (line 1390) | struct Construct<T, A, false, false, true, false>
method load_andor_construct (line 1392) | static void load_andor_construct( A & ar, construct<T> & construct )
type Construct<T, A, false, false, false, true> (line 1400) | struct Construct<T, A, false, false, false, true>
method load_andor_construct (line 1402) | static void load_andor_construct( A & ar, construct<T> & construct )
FILE: examples/libraries/cereal-1.3.0/include/cereal/details/util.hpp
type cereal (line 37) | namespace cereal
type util (line 39) | namespace util
function demangle (line 43) | inline std::string demangle( std::string const & name )
function demangledName (line 48) | inline
function demangle (line 62) | inline std::string demangle(std::string mangledName)
function demangledName (line 78) | inline
type util (line 58) | namespace util
function demangle (line 43) | inline std::string demangle( std::string const & name )
function demangledName (line 48) | inline
function demangle (line 62) | inline std::string demangle(std::string mangledName)
function demangledName (line 78) | inline
type cereal (line 56) | namespace cereal
type util (line 39) | namespace util
function demangle (line 43) | inline std::string demangle( std::string const & name )
function demangledName (line 48) | inline
function demangle (line 62) | inline std::string demangle(std::string mangledName)
function demangledName (line 78) | inline
type util (line 58) | namespace util
function demangle (line 43) | inline std::string demangle( std::string const & name )
function demangledName (line 48) | inline
function demangle (line 62) | inline std::string demangle(std::string mangledName)
function demangledName (line 78) | inline
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/base64.hpp
type cereal (line 35) | namespace cereal
type base64 (line 37) | namespace base64
function is_base64 (line 44) | static inline bool is_base64(unsigned char c) {
function encode (line 48) | inline std::string encode(unsigned char const* bytes_to_encode, size...
function decode (line 89) | inline std::string decode(std::string const& encoded_string) {
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/allocators.h
function class (line 75) | class CrtAllocator {
function Clear (line 158) | void Clear() {
function Capacity (line 171) | size_t Capacity() const {
function Free (line 238) | static void Free(void *ptr) { (void)ptr; }
function AddChunk (line 250) | bool AddChunk(size_t capacity) {
type ChunkHeader (line 269) | struct ChunkHeader {
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/cursorstreamwrapper.h
function Ch (line 47) | Ch Take() {
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/document.h
type GenericMember (line 107) | typedef GenericMember<Encoding,Allocator> PlainType;
type typename (line 108) | typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
type ValueType (line 120) | typedef ValueType value_type;
type ValueType (line 121) | typedef ValueType * pointer;
type ValueType (line 122) | typedef ValueType & reference;
type std (line 123) | typedef std::ptrdiff_t difference_type;
type std (line 124) | typedef std::random_access_iterator_tag iterator_category;
type pointer (line 128) | typedef pointer Pointer;
type reference (line 130) | typedef reference Reference;
type difference_type (line 132) | typedef difference_type DifferenceType;
function ptr_ (line 156) | GenericMemberIterator(const NonConstIterator & it) : ptr_(it.ptr_) {}
function ConstIterator (line 178) | bool operator==(ConstIterator that) const { return ptr_ == that.ptr_; }
function ConstIterator (line 179) | bool operator!=(ConstIterator that) const { return ptr_ != that.ptr_; }
function ConstIterator (line 180) | bool operator<=(ConstIterator that) const { return ptr_ <= that.ptr_; }
function ConstIterator (line 181) | bool operator>=(ConstIterator that) const { return ptr_ >= that.ptr_; }
function operator (line 182) | bool operator< (ConstIterator that) const { return ptr_ < that.ptr_; }
function operator (line 183) | bool operator> (ConstIterator that) const { return ptr_ > that.ptr_; }
function Reference (line 188) | Reference operator*() const { return *ptr_; }
function Pointer (line 189) | Pointer operator->() const { return ptr_; }
function Reference (line 190) | Reference operator[](DifferenceType n) const { return ptr_[n]; }
type CharType (line 257) | typedef CharType Ch;
function explicit (line 309) | explicit GenericStringRef(const CharType* str)
function operator (line 327) | operator const Ch *() const { return s; }
function namespace (line 409) | namespace internal {
function Is (line 433) | static bool Is(const ValueType& v) { return v.IsBool(); }
function Get (line 434) | static bool Get(const ValueType& v) { return v.GetBool(); }
function Is (line 441) | static bool Is(const ValueType& v) { return v.IsInt(); }
function Get (line 442) | static int Get(const ValueType& v) { return v.GetInt(); }
function Is (line 449) | static bool Is(const ValueType& v) { return v.IsUint(); }
function Get (line 450) | static unsigned Get(const ValueType& v) { return v.GetUint(); }
function Is (line 459) | static bool Is(const ValueType& v) { return v.IsInt(); }
function Get (line 460) | static long Get(const ValueType& v) { return v.GetInt(); }
function Is (line 468) | static bool Is(const ValueType& v) { return v.IsUint(); }
function Get (line 469) | static unsigned long Get(const ValueType& v) { return v.GetUint(); }
function Is (line 477) | static bool Is(const ValueType& v) { return v.IsInt64(); }
function Get (line 478) | static int64_t Get(const ValueType& v) { return v.GetInt64(); }
function Is (line 485) | static bool Is(const ValueType& v) { return v.IsUint64(); }
function Get (line 486) | static uint64_t Get(const ValueType& v) { return v.GetUint64(); }
function Is (line 493) | static bool Is(const ValueType& v) { return v.IsDouble(); }
function Get (line 494) | static double Get(const ValueType& v) { return v.GetDouble(); }
function Is (line 501) | static bool Is(const ValueType& v) { return v.IsFloat(); }
function Get (line 502) | static float Get(const ValueType& v) { return v.GetFloat(); }
type typename (line 509) | typedef const typename ValueType::Ch* StringType;
function Is (line 510) | static bool Is(const ValueType& v) { return v.IsString(); }
function StringType (line 511) | static StringType Get(const ValueType& v) { return v.GetString(); }
function Is (line 520) | static bool Is(const ValueType& v) { return v.IsString(); }
function StringType (line 521) | static StringType Get(const ValueType& v) { return StringType(v.GetStrin...
type typename (line 528) | typedef typename ValueType::Array ArrayType;
function Is (line 529) | static bool Is(const ValueType& v) { return v.IsArray(); }
function ArrayType (line 530) | static ArrayType Get(ValueType& v) { return v.GetArray(); }
type typename (line 537) | typedef typename ValueType::ConstArray ArrayType;
function Is (line 538) | static bool Is(const ValueType& v) { return v.IsArray(); }
function ArrayType (line 539) | static ArrayType Get(const ValueType& v) { return v.GetArray(); }
type typename (line 544) | typedef typename ValueType::Object ObjectType;
function Is (line 545) | static bool Is(const ValueType& v) { return v.IsObject(); }
function ObjectType (line 546) | static ObjectType Get(ValueType& v) { return v.GetObject(); }
type typename (line 553) | typedef typename ValueType::ConstObject ObjectType;
function Is (line 554) | static bool Is(const ValueType& v) { return v.IsObject(); }
function ObjectType (line 555) | static ObjectType Get(const ValueType& v) { return v.GetObject(); }
type Encoding (line 582) | typedef Encoding EncodingType;
type Allocator (line 583) | typedef Allocator AllocatorType;
type typename (line 584) | typedef typename Encoding::Ch Ch;
type GenericStringRef (line 585) | typedef GenericStringRef<Ch> StringRefType;
type typename (line 586) | typedef typename GenericMemberIterator<false,Encoding,Allocator>::Iterat...
type typename (line 587) | typedef typename GenericMemberIterator<true,Encoding,Allocator>::Iterato...
type GenericValue (line 588) | typedef GenericValue* ValueIterator;
type GenericValue (line 589) | typedef const GenericValue* ConstValueIterator;
type GenericValue (line 590) | typedef GenericValue<Encoding, Allocator> ValueType;
function explicit (line 703) | explicit GenericValue(bool b) CEREAL_RAPIDJSON_NOEXCEPT
function explicit (line 712) | explicit GenericValue(int i) CEREAL_RAPIDJSON_NOEXCEPT : data_() {
function explicit (line 718) | explicit GenericValue(unsigned u) CEREAL_RAPIDJSON_NOEXCEPT : data_() {
function explicit (line 724) | explicit GenericValue(int64_t i64) CEREAL_RAPIDJSON_NOEXCEPT : data_() {
function explicit (line 739) | explicit GenericValue(uint64_t u64) CEREAL_RAPIDJSON_NOEXCEPT : data_() {
function explicit (line 751) | explicit GenericValue(double d) CEREAL_RAPIDJSON_NOEXCEPT : data_() { da...
function explicit (line 754) | explicit GenericValue(float f) CEREAL_RAPIDJSON_NOEXCEPT : data_() { dat...
function explicit (line 760) | explicit GenericValue(StringRefType s) CEREAL_RAPIDJSON_NOEXCEPT : data_...
function data_ (line 781) | GenericValue(Array a) CEREAL_RAPIDJSON_NOEXCEPT : data_(a.value_.data_) {
function data_ (line 792) | GenericValue(Object o) CEREAL_RAPIDJSON_NOEXCEPT : data_(o.value_.data_) {
type GenericValue (line 936) | typedef GenericValue<Encoding, SourceAllocator> RhsType;
function rhs (line 983) | bool operator==(const std::basic_string<Ch>& rhs) const { return *this =...
function GetBool (line 1084) | bool GetBool() const { CEREAL_RAPIDJSON_ASSERT(IsBool()); return data_.f...
function SizeType (line 1099) | SizeType MemberCount() const { CEREAL_RAPIDJSON_ASSERT(IsObject()); retu...
function ObjectEmpty (line 1105) | bool ObjectEmpty() const { CEREAL_RAPIDJSON_ASSERT(IsObject()); return d...
function GenericValue (line 1156) | const GenericValue& operator[](const std::basic_string<Ch>& name) const ...
function ConstMemberIterator (line 1161) | ConstMemberIterator MemberBegin() const { CEREAL_RAPIDJSON_ASSERT(IsObje...
function MemberIterator (line 1167) | MemberIterator MemberBegin() { CEREAL_RAPIDJSON_ASSERT(IsObje...
function MemberIterator (line 1170) | MemberIterator MemberEnd() { CEREAL_RAPIDJSON_ASSERT(IsObje...
function HasMember (line 1195) | bool HasMember(const Ch* name) const { return FindMember(name) != Member...
function HasMember (line 1206) | bool HasMember(const std::basic_string<Ch>& name) const { return FindMem...
function MemberIterator (line 1233) | MemberIterator FindMember(const Ch* name) {
function ConstMemberIterator (line 1238) | ConstMemberIterator FindMember(const Ch* name) const { return const_cast...
function MemberIterator (line 1273) | MemberIterator FindMember(const std::basic_string<Ch>& name) { return Fi...
function ConstMemberIterator (line 1274) | ConstMemberIterator FindMember(const std::basic_string<Ch>& name) const ...
function RemoveAllMembers (line 1429) | void RemoveAllMembers() {
function RemoveMember (line 1444) | bool RemoveMember(const Ch* name) {
function MemberIterator (line 1472) | MemberIterator RemoveMember(MemberIterator m) {
function MemberIterator (line 1496) | MemberIterator EraseMember(ConstMemberIterator pos) {
function MemberIterator (line 1509) | MemberIterator EraseMember(ConstMemberIterator first, ConstMemberIterato...
function EraseMember (line 1530) | bool EraseMember(const Ch* name) {
function Object (line 1550) | Object GetObject() { CEREAL_RAPIDJSON_ASSERT(IsObject()); return Object(...
function ConstObject (line 1551) | ConstObject GetObject() const { CEREAL_RAPIDJSON_ASSERT(IsObject()); ret...
function SizeType (line 1563) | SizeType Size() const { CEREAL_RAPIDJSON_ASSERT(IsArray()); return data_...
function Empty (line 1569) | bool Empty() const { CEREAL_RAPIDJSON_ASSERT(IsArray()); return data_.a....
function GenericValue (line 1593) | const GenericValue& operator[](SizeType index) const { return const_cast...
function ValueIterator (line 1597) | ValueIterator Begin() { CEREAL_RAPIDJSON_ASSERT(IsArray()); return GetEl...
function ValueIterator (line 1600) | ValueIterator End() { CEREAL_RAPIDJSON_ASSERT(IsArray()); return GetElem...
function ValueIterator (line 1702) | ValueIterator Erase(ConstValueIterator pos) {
function ValueIterator (line 1714) | ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) {
function Array (line 1729) | Array GetArray() { CEREAL_RAPIDJSON_ASSERT(IsArray()); return Array(*thi...
function ConstArray (line 1730) | ConstArray GetArray() const { CEREAL_RAPIDJSON_ASSERT(IsArray()); return...
function GetDouble (line 1745) | double GetDouble() const {
function Ch (line 1773) | const Ch* GetString() const { CEREAL_RAPIDJSON_ASSERT(IsString()); retur...
function SizeType (line 1778) | SizeType GetStringLength() const { CEREAL_RAPIDJSON_ASSERT(IsString()); ...
type Flag (line 1945) | struct Flag {
type String (line 1956) | struct String {
function SetLength (line 1970) | struct ShortString {
type I (line 1982) | struct I {
type U (line 1986) | struct U {
type I (line 1991) | struct I {
type U (line 1995) | struct U {
type ObjectData (line 2005) | struct ObjectData {
type ArrayData (line 2011) | struct ArrayData {
function CEREAL_RAPIDJSON_FORCEINLINE (line 2026) | CEREAL_RAPIDJSON_FORCEINLINE const Ch* GetStringPointer() const { return...
function CEREAL_RAPIDJSON_FORCEINLINE (line 2027) | CEREAL_RAPIDJSON_FORCEINLINE const Ch* SetStringPointer(const Ch* str) {...
function CEREAL_RAPIDJSON_FORCEINLINE (line 2028) | CEREAL_RAPIDJSON_FORCEINLINE GenericValue* GetElementsPointer() const { ...
function CEREAL_RAPIDJSON_FORCEINLINE (line 2029) | CEREAL_RAPIDJSON_FORCEINLINE GenericValue* SetElementsPointer(GenericVal...
function CEREAL_RAPIDJSON_FORCEINLINE (line 2030) | CEREAL_RAPIDJSON_FORCEINLINE Member* GetMembersPointer() const { return ...
function CEREAL_RAPIDJSON_FORCEINLINE (line 2031) | CEREAL_RAPIDJSON_FORCEINLINE Member* SetMembersPointer(Member* members) ...
function SetArrayRaw (line 2034) | void SetArrayRaw(GenericValue* values, SizeType count, Allocator& alloca...
function SetObjectRaw (line 2047) | void SetObjectRaw(Member* members, SizeType count, Allocator& allocator) {
function SetStringRaw (line 2060) | void SetStringRaw(StringRefType s) CEREAL_RAPIDJSON_NOEXCEPT {
function SetStringRaw (line 2067) | void SetStringRaw(StringRefType s, Allocator& allocator) {
function RawAssign (line 2084) | void RawAssign(GenericValue& rhs) CEREAL_RAPIDJSON_NOEXCEPT {
type GenericValue (line 2110) | typedef GenericValue<UTF8<> > Value;
type GenericValue (line 2127) | typedef GenericValue<Encoding, Allocator> ValueType;
type Allocator (line 2128) | typedef Allocator AllocatorType;
type ClearStackOnExit (line 2422) | struct ClearStackOnExit {
function Bool (line 2438) | bool Bool(bool b) { new (stack_.template Push<ValueType>()) ValueType(b)...
function Int (line 2439) | bool Int(int i) { new (stack_.template Push<ValueType>()) ValueType(i); ...
function Uint (line 2440) | bool Uint(unsigned i) { new (stack_.template Push<ValueType>()) ValueTyp...
function Int64 (line 2441) | bool Int64(int64_t i) { new (stack_.template Push<ValueType>()) ValueTyp...
function Uint64 (line 2442) | bool Uint64(uint64_t i) { new (stack_.template Push<ValueType>()) ValueT...
function Double (line 2443) | bool Double(double d) { new (stack_.template Push<ValueType>()) ValueTyp...
function RawNumber (line 2445) | bool RawNumber(const Ch* str, SizeType length, bool copy) {
function String (line 2453) | bool String(const Ch* str, SizeType length, bool copy) {
function StartObject (line 2461) | bool StartObject() { new (stack_.template Push<ValueType>()) ValueType(k...
function Key (line 2463) | bool Key(const Ch* str, SizeType length, bool copy) { return String(str,...
function EndObject (line 2465) | bool EndObject(SizeType memberCount) {
function StartArray (line 2471) | bool StartArray() { new (stack_.template Push<ValueType>()) ValueType(kA...
function EndArray (line 2473) | bool EndArray(SizeType elementCount) {
function ClearStack (line 2485) | void ClearStack() {
function Destroy (line 2494) | void Destroy() {
type GenericDocument (line 2506) | typedef GenericDocument<UTF8<> > Document;
type ValueT (line 2518) | typedef ValueT PlainType;
type typename (line 2519) | typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
type ValueType (line 2520) | typedef ValueType* ValueIterator;
type ValueT (line 2521) | typedef const ValueT* ConstValueIterator;
type typename (line 2522) | typedef typename ValueType::AllocatorType AllocatorType;
type typename (line 2523) | typedef typename ValueType::StringRefType StringRefType;
function value_ (line 2528) | GenericArray(const GenericArray& rhs) : value_(rhs.value_) {}
function GenericArray (line 2539) | GenericArray Reserve(SizeType newCapacity, AllocatorType &allocator) con...
function GenericArray (line 2540) | GenericArray PushBack(ValueType& value, AllocatorType& allocator) const ...
function GenericArray (line 2542) | GenericArray PushBack(ValueType&& value, AllocatorType& allocator) const...
function GenericArray (line 2544) | GenericArray PushBack(StringRefType value, AllocatorType& allocator) con...
function ValueIterator (line 2547) | ValueIterator Erase(ConstValueIterator pos) const { return value_.Erase(...
function ValueIterator (line 2548) | ValueIterator Erase(ConstValueIterator first, ConstValueIterator last) c...
function value_ (line 2557) | value_(value) {}
type ValueT (line 2571) | typedef ValueT PlainType;
type typename (line 2572) | typedef typename internal::MaybeAddConst<Const,PlainType>::Type ValueType;
type GenericMemberIterator (line 2573) | typedef GenericMemberIterator<Const, typename
type GenericMemberIterator (line 2574) | typedef GenericMemberIterator<true, typename
type typename (line 2575) | typedef typename ValueType::AllocatorType AllocatorType;
type typename (line 2576) | typedef typename ValueType::StringRefType StringRefType;
type typename (line 2577) | typedef typename ValueType::EncodingType EncodingType;
type typename (line 2578) | typedef typename ValueType::Ch Ch;
function value_ (line 2583) | GenericObject(const GenericObject& rhs) : value_(rhs.value_) {}
function GenericObject (line 2597) | GenericObject MemberReserve(SizeType newCapacity, AllocatorType &allocat...
function HasMember (line 2598) | bool HasMember(const Ch* name) const { return value_.HasMember(name); }
function MemberIterator (line 2603) | MemberIterator FindMember(const Ch* name) const { return value_.FindMemb...
function GenericObject (line 2611) | GenericObject AddMember(ValueType& name, std::basic_string<Ch>& value, A...
function GenericObject (line 2615) | GenericObject AddMember(ValueType&& name, ValueType&& value, AllocatorTy...
function GenericObject (line 2616) | GenericObject AddMember(ValueType&& name, ValueType& value, AllocatorTyp...
function GenericObject (line 2617) | GenericObject AddMember(ValueType& name, ValueType&& value, AllocatorTyp...
function GenericObject (line 2618) | GenericObject AddMember(StringRefType name, ValueType&& value, Allocator...
function GenericObject (line 2620) | GenericObject AddMember(StringRefType name, ValueType& value, AllocatorT...
function GenericObject (line 2621) | GenericObject AddMember(StringRefType name, StringRefType value, Allocat...
function RemoveMember (line 2624) | bool RemoveMember(const Ch* name) const { return value_.RemoveMember(nam...
function value_ (line 2645) | value_(value) {}
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/encodedstream.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 27) | CEREAL_RAPIDJSON_DIAG_PUSH
function Ch (line 49) | Ch Take() { Ch c = current_; current_ = Encoding::Take(is_); return c; }
function Put (line 53) | void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
function Flush (line 54) | void Flush() { CEREAL_RAPIDJSON_ASSERT(false); }
function Ch (line 55) | Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function PutEnd (line 56) | size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function is_ (line 72) | is_(is) {
function Ch (line 78) | Ch Take() { return is_.Take(); }
function Put (line 82) | void Put(Ch) {}
function Flush (line 83) | void Flush() {}
function Ch (line 84) | Ch* PutBegin() { return 0; }
function PutEnd (line 85) | size_t PutEnd(Ch*) { return 0; }
function os_ (line 105) | os_(os) {
function Put (line 110) | void Put(Ch c) { Encoding::Put(os_, c); }
function Flush (line 111) | void Flush() { os_.Flush(); }
function Ch (line 115) | Ch Take() { CEREAL_RAPIDJSON_ASSERT(false); return 0;}
function Tell (line 116) | size_t Tell() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function Ch (line 157) | Ch Take() { Ch c = current_; current_ = takeFunc_(*is_); return c; }
function Put (line 161) | void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
function Flush (line 162) | void Flush() { CEREAL_RAPIDJSON_ASSERT(false); }
function Ch (line 163) | Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function PutEnd (line 164) | size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function DetectType (line 171) | void DetectType() {
type Ch (line 219) | typedef Ch (*TakeFunc)(InputByteStream& is);
function Put (line 260) | void Put(Ch c) { putFunc_(*os_, c); }
function Flush (line 261) | void Flush() { os_->Flush(); }
function Ch (line 265) | Ch Take() { CEREAL_RAPIDJSON_ASSERT(false); return 0;}
function Tell (line 266) | size_t Tell() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function PutBOM (line 274) | void PutBOM() {
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/encodings.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 25) | CEREAL_RAPIDJSON_DIAG_PUSH
function else (line 131) | else if (codepoint <= 0xFFFF) {
function GetRange (line 204) | static unsigned char GetRange(unsigned char c) {
type CharType (line 270) | typedef CharType Ch;
type CharType (line 419) | typedef CharType Ch;
type CharType (line 543) | typedef CharType Ch;
type UTFType (line 603) | enum UTFType {
type CharType (line 616) | typedef CharType Ch;
function Encode (line 623) | void Encode(OutputStream& os, unsigned codepoint) {
function EncodeUnsafe (line 630) | void EncodeUnsafe(OutputStream& os, unsigned codepoint) {
function Decode (line 637) | bool Decode(InputStream& is, unsigned* codepoint) {
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/error/en.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 21) | CEREAL_RAPIDJSON_DIAG_PUSH
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/error/error.h
function CEREAL_RAPIDJSON_NAMESPACE_BEGIN (line 55) | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
type CEREAL_RAPIDJSON_ERROR_CHARTYPE (line 153) | typedef const CEREAL_RAPIDJSON_ERROR_CHARTYPE* (*GetParseErrorFunc)(Pars...
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/filereadstream.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 22) | CEREAL_RAPIDJSON_DIAG_PUSH
function Ch (line 51) | Ch Take() { Ch c = *current_; Read(); return c; }
function Put (line 55) | void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
function Flush (line 56) | void Flush() { CEREAL_RAPIDJSON_ASSERT(false); }
function Ch (line 57) | Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function PutEnd (line 58) | size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function Ch (line 61) | const Ch* Peek4() const {
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/filewritestream.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 22) | CEREAL_RAPIDJSON_DIAG_PUSH
function Put (line 40) | void Put(char c) {
function PutN (line 47) | void PutN(char c, size_t n) {
function Flush (line 63) | void Flush() {
function Peek (line 75) | char Peek() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function Tell (line 77) | size_t Tell() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function PutEnd (line 79) | size_t PutEnd(char*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function PutN (line 94) | inline void PutN(FileWriteStream& stream, char c, size_t n) {
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/fwd.h
type GenericStringStream (line 49) | typedef GenericStringStream<UTF8<char> > StringStream;
type GenericInsituStringStream (line 54) | typedef GenericInsituStringStream<UTF8<char> > InsituStringStream;
type GenericStringBuffer (line 61) | typedef GenericStringBuffer<UTF8<char>, CrtAllocator> StringBuffer;
type GenericMemoryBuffer (line 76) | typedef GenericMemoryBuffer<CrtAllocator> MemoryBuffer;
type MemoryStream (line 80) | struct MemoryStream
type GenericReader (line 90) | typedef GenericReader<UTF8<char>, UTF8<char>, CrtAllocator> Reader;
type GenericValue (line 116) | typedef GenericValue<UTF8<char>, MemoryPoolAllocator<CrtAllocator> > Value;
type GenericDocument (line 121) | typedef GenericDocument<UTF8<char>, MemoryPoolAllocator<CrtAllocator>, C...
type GenericPointer (line 128) | typedef GenericPointer<Value, CrtAllocator> Pointer;
type GenericSchemaDocument (line 138) | typedef GenericSchemaDocument<Value, CrtAllocator> SchemaDocument;
type IGenericRemoteSchemaDocumentProvider (line 139) | typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSche...
type GenericSchemaValidator (line 147) | typedef GenericSchemaValidator<SchemaDocument, BaseReaderHandler<UTF8<ch...
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/biginteger.h
function CEREAL_RAPIDJSON_NAMESPACE_BEGIN (line 25) | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
function Difference (line 186) | bool Difference(const BigInteger& rhs, BigInteger* out) const {
function Compare (line 208) | int Compare(const BigInteger& rhs) const {
function Type (line 220) | Type GetDigit(size_t index) const { CEREAL_RAPIDJSON_ASSERT(index < coun...
function PushBack (line 234) | void PushBack(Type digit) {
function ParseUint64 (line 239) | static uint64_t ParseUint64(const char* begin, const char* end) {
function MulAdd64 (line 249) | static uint64_t MulAdd64(uint64_t a, uint64_t b, uint64_t k, uint64_t* o...
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/diyfp.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 40) | CEREAL_RAPIDJSON_DIAG_PUSH
type uint128 (line 79) | __extension__ typedef unsigned __int128 uint128;
function DiyFp (line 121) | DiyFp NormalizeBoundary() const {
function NormalizedBoundaries (line 132) | void NormalizedBoundaries(DiyFp* minus, DiyFp* plus) const {
function ToDouble (line 141) | double ToDouble() const {
function DiyFp (line 175) | inline DiyFp GetCachedPowerByIndex(size_t index) {
function DiyFp (line 238) | inline DiyFp GetCachedPower(int e, int* K) {
function DiyFp (line 252) | inline DiyFp GetCachedPower10(int exp, int *outExp) {
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/dtoa.h
function CEREAL_RAPIDJSON_NAMESPACE_BEGIN (line 26) | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/ieee754.h
function CEREAL_RAPIDJSON_NAMESPACE_BEGIN (line 20) | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/itoa.h
function CEREAL_RAPIDJSON_NAMESPACE_BEGIN (line 20) | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/meta.h
function CEREAL_RAPIDJSON_NAMESPACE_BEGIN (line 35) | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/pow10.h
function CEREAL_RAPIDJSON_NAMESPACE_BEGIN (line 20) | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/regex.h
function CEREAL_RAPIDJSON_NAMESPACE_BEGIN (line 44) | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
function SizeType (line 322) | SizeType NewState(SizeType out, SizeType out1, unsigned codepoint) {
function PushOperand (line 331) | void PushOperand(Stack<Allocator>& operandStack, unsigned codepoint) {
function ImplicitConcatenation (line 336) | void ImplicitConcatenation(Stack<Allocator>& atomCountStack, Stack<Alloc...
function SizeType (line 342) | SizeType Append(SizeType l1, SizeType l2) {
function Patch (line 350) | void Patch(SizeType l, SizeType s) {
function Eval (line 357) | bool Eval(Stack<Allocator>& operandStack, Operator op) {
function EvalQuantifier (line 414) | bool EvalQuantifier(Stack<Allocator>& operandStack, unsigned n, unsigned...
function SizeType (line 453) | static SizeType Min(SizeType a, SizeType b) { return a < b ? a : b; }
function CloneTopOperand (line 455) | void CloneTopOperand(Stack<Allocator>& operandStack) {
function SizeType (line 555) | SizeType NewRange(unsigned codepoint) {
type typename (line 610) | typedef typename Encoding::Ch Ch;
function Match (line 634) | bool Match(const Ch* s) {
function Search (line 644) | bool Search(const Ch* s) {
type typename (line 651) | typedef typename RegexType::Range Range;
function AddState (line 692) | bool AddState(Stack<Allocator>& l, SizeType index) {
function MatchRange (line 707) | bool MatchRange(SizeType rangeIndex, unsigned codepoint) const {
type GenericRegex (line 726) | typedef GenericRegex<UTF8<> > Regex;
type GenericRegexSearch (line 727) | typedef GenericRegexSearch<Regex> RegexSearch;
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/stack.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 23) | CEREAL_RAPIDJSON_DIAG_PUSH
function T (line 151) | T* Top() const {
function T (line 160) | T* End() const { return reinterpret_cast<T*>(stackTop_); }
function T (line 166) | T* Bottom() const { return reinterpret_cast<T*>(stack_); }
function Resize (line 201) | void Resize(size_t newCapacity) {
function Destroy (line 208) | void Destroy() {
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/strfunc.h
function CEREAL_RAPIDJSON_NAMESPACE_BEGIN (line 21) | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/strtod.h
function CEREAL_RAPIDJSON_NAMESPACE_BEGIN (line 25) | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/internal/swap.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 21) | CEREAL_RAPIDJSON_DIAG_PUSH
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/istreamwrapper.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 26) | CEREAL_RAPIDJSON_DIAG_PUSH
function Ch (line 73) | Ch Take() { Ch c = *current_; Read(); return c; }
function Put (line 77) | void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
function Flush (line 78) | void Flush() { CEREAL_RAPIDJSON_ASSERT(false); }
function Ch (line 79) | Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function PutEnd (line 80) | size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function Ch (line 83) | const Ch* Peek4() const {
function Read (line 92) | void Read() {
type BasicIStreamWrapper (line 119) | typedef BasicIStreamWrapper<std::istream> IStreamWrapper;
type BasicIStreamWrapper (line 120) | typedef BasicIStreamWrapper<std::wistream> WIStreamWrapper;
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/memorystream.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 21) | CEREAL_RAPIDJSON_DIAG_PUSH
function Ch (line 46) | Ch Take() { return CEREAL_RAPIDJSON_UNLIKELY(src_ == end_) ? '\0' : *src...
function Ch (line 49) | Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function Put (line 50) | void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
function Flush (line 51) | void Flush() { CEREAL_RAPIDJSON_ASSERT(false); }
function PutEnd (line 52) | size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function Ch (line 55) | const Ch* Peek4() const {
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/msinttypes/inttypes.h
type imaxdiv_t (line 57) | typedef struct {
function _inline (line 286) | static
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/msinttypes/stdint.h
type int_least8_t (line 140) | typedef int8_t int_least8_t;
type int_least16_t (line 141) | typedef int16_t int_least16_t;
type int_least32_t (line 142) | typedef int32_t int_least32_t;
type int_least64_t (line 143) | typedef int64_t int_least64_t;
type uint_least8_t (line 144) | typedef uint8_t uint_least8_t;
type uint_least16_t (line 145) | typedef uint16_t uint_least16_t;
type uint_least32_t (line 146) | typedef uint32_t uint_least32_t;
type uint_least64_t (line 147) | typedef uint64_t uint_least64_t;
type int_fast8_t (line 150) | typedef int8_t int_fast8_t;
type int_fast16_t (line 151) | typedef int16_t int_fast16_t;
type int_fast32_t (line 152) | typedef int32_t int_fast32_t;
type int_fast64_t (line 153) | typedef int64_t int_fast64_t;
type uint_fast8_t (line 154) | typedef uint8_t uint_fast8_t;
type uint_fast16_t (line 155) | typedef uint16_t uint_fast16_t;
type uint_fast32_t (line 156) | typedef uint32_t uint_fast32_t;
type uint_fast64_t (line 157) | typedef uint64_t uint_fast64_t;
type intmax_t (line 169) | typedef int64_t intmax_t;
type uintmax_t (line 170) | typedef uint64_t uintmax_t;
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/ostreamwrapper.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 22) | CEREAL_RAPIDJSON_DIAG_PUSH
function Put (line 50) | void Put(Ch c) {
function Flush (line 54) | void Flush() {
function Peek (line 59) | char Peek() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function Tell (line 61) | size_t Tell() const { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function PutEnd (line 63) | size_t PutEnd(char*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
type BasicOStreamWrapper (line 72) | typedef BasicOStreamWrapper<std::ostream> OStreamWrapper;
type BasicOStreamWrapper (line 73) | typedef BasicOStreamWrapper<std::wostream> WOStreamWrapper;
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/pointer.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 25) | CEREAL_RAPIDJSON_DIAG_PUSH
function Token (line 353) | const Token* GetTokens() const { return tokens_; }
function Erase (line 771) | bool Erase(ValueType& root) const {
function NeedPercentEncode (line 850) | bool NeedPercentEncode(Ch c) const {
function Parse (line 862) | void Parse(const Ch* source, size_t length) {
function class (line 1040) | class PercentDecodeStream {
function Put (line 1088) | void Put(char c) { // UTF-8 must be byte
type GenericPointer (line 1109) | typedef GenericPointer<Value> Pointer;
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/prettywriter.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 26) | CEREAL_RAPIDJSON_DIAG_PUSH
function Null (line 95) | bool Null() { PrettyPrefix(kNullType); return Base::En...
function Bool (line 96) | bool Bool(bool b) { PrettyPrefix(b ? kTrueType : kFalseType); ...
function Int (line 97) | bool Int(int i) { PrettyPrefix(kNumberType); return Base::En...
function Uint (line 98) | bool Uint(unsigned u) { PrettyPrefix(kNumberType); return Base::En...
function Int64 (line 99) | bool Int64(int64_t i64) { PrettyPrefix(kNumberType); return Base::En...
function Uint64 (line 100) | bool Uint64(uint64_t u64) { PrettyPrefix(kNumberType); return Base::En...
function Double (line 101) | bool Double(double d) { PrettyPrefix(kNumberType); return Base::En...
function StartObject (line 123) | bool StartObject() {
function StartArray (line 157) | bool StartArray() {
function String (line 187) | bool String(const Ch* str) { return String(str, internal::StrLen(str)); }
function Key (line 188) | bool Key(const Ch* str) { return Key(str, internal::StrLen(str)); }
function RawValue (line 201) | bool RawValue(const Ch* json, size_t length, Type type) {
function WriteIndent (line 252) | void WriteIndent() {
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/rapidjson.h
type STATIC_ASSERTION_FAILURE (line 427) | struct STATIC_ASSERTION_FAILURE
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/reader.h
function CEREAL_RAPIDJSON_DIAG_PUSH (line 46) | CEREAL_RAPIDJSON_DIAG_PUSH
type ParseFlag (line 145) | enum ParseFlag {
type typename (line 197) | typedef typename Encoding::Ch Ch;
type typename (line 199) | typedef typename internal::SelectIf<internal::IsSame<Derived, void>, Bas...
function Default (line 201) | bool Default() { return true; }
function Null (line 202) | bool Null() { return static_cast<Override&>(*this).Default(); }
function Bool (line 203) | bool Bool(bool) { return static_cast<Override&>(*this).Default(); }
function Int (line 204) | bool Int(int) { return static_cast<Override&>(*this).Default(); }
function Uint (line 205) | bool Uint(unsigned) { return static_cast<Override&>(*this).Default(); }
function Int64 (line 206) | bool Int64(int64_t) { return static_cast<Override&>(*this).Default(); }
function Uint64 (line 207) | bool Uint64(uint64_t) { return static_cast<Override&>(*this).Default(); }
function Double (line 208) | bool Double(double) { return static_cast<Override&>(*this).Default(); }
function RawNumber (line 210) | bool RawNumber(const Ch* str, SizeType len, bool copy) { return static_c...
function String (line 211) | bool String(const Ch*, SizeType, bool) { return static_cast<Override&>(*...
function StartObject (line 212) | bool StartObject() { return static_cast<Override&>(*this).Default(); }
function Key (line 213) | bool Key(const Ch* str, SizeType len, bool copy) { return static_cast<Ov...
function EndObject (line 214) | bool EndObject(SizeType) { return static_cast<Override&>(*this).Default(...
function StartArray (line 215) | bool StartArray() { return static_cast<Override&>(*this).Default(); }
function EndArray (line 216) | bool EndArray(SizeType) { return static_cast<Override&>(*this).Default(); }
function namespace (line 222) | namespace internal {
function SkipWhitespace (line 503) | inline void SkipWhitespace(InsituStringStream& is) {
function SkipWhitespace (line 508) | inline void SkipWhitespace(StringStream& is) {
function SkipWhitespace (line 512) | inline void SkipWhitespace(EncodedInputStream<UTF8<>, MemoryStream>& is) {
function IterativeParseInit (line 605) | void IterativeParseInit() {
function ClearStack (line 696) | void ClearStack() { stack_.Clear(); }
type ClearStackOnExit (line 699) | struct ClearStackOnExit {
function Consume (line 893) | bool Consume(InputStream& is, typename InputStream::Ch expect) {
function CEREAL_RAPIDJSON_FORCEINLINE (line 931) | CEREAL_RAPIDJSON_FORCEINLINE void Put(Ch c) {
function CEREAL_RAPIDJSON_FORCEINLINE (line 936) | CEREAL_RAPIDJSON_FORCEINLINE void* Push(SizeType count) {
function Ch (line 943) | Ch* Pop() {
type typename (line 1399) | typedef typename InputStream::Ch Ch;
function is (line 1401) | is(s) { (void)reader; }
function CEREAL_RAPIDJSON_FORCEINLINE (line 1404) | CEREAL_RAPIDJSON_FORCEINLINE Ch TakePush() { return is.Take(); }
function CEREAL_RAPIDJSON_FORCEINLINE (line 1405) | CEREAL_RAPIDJSON_FORCEINLINE Ch Take() { return is.Take(); }
function CEREAL_RAPIDJSON_FORCEINLINE (line 1406) | CEREAL_RAPIDJSON_FORCEINLINE void Push(char) {}
function Tell (line 1408) | size_t Tell() { return is.Tell(); }
function Length (line 1409) | size_t Length() { return 0; }
function CEREAL_RAPIDJSON_FORCEINLINE (line 1424) | CEREAL_RAPIDJSON_FORCEINLINE Ch TakePush() {
function CEREAL_RAPIDJSON_FORCEINLINE (line 1429) | CEREAL_RAPIDJSON_FORCEINLINE void Push(char c) {
function Length (line 1433) | size_t Length() { return stackStream.Length(); }
function CEREAL_RAPIDJSON_FORCEINLINE (line 1450) | CEREAL_RAPIDJSON_FORCEINLINE Ch Take() { return Base::TakePush(); }
type IterativeParsingState (line 1754) | enum IterativeParsingState {
type Token (line 1782) | enum Token {
function CEREAL_RAPIDJSON_FORCEINLINE (line 1801) | CEREAL_RAPIDJSON_FORCEINLINE Token Tokenize(Ch c) const {
function CEREAL_RAPIDJSON_FORCEINLINE (line 1828) | CEREAL_RAPIDJSON_FORCEINLINE IterativeParsingState Predict(IterativePars...
function IterativeParsingState (line 1995) | IterativeParsingState Transit(IterativeParsingState src, Token token, It...
function CEREAL_RAPIDJSON_FORCEINLINE (line 2167) | CEREAL_RAPIDJSON_FORCEINLINE bool IsIterativeParsingDelimiterState(Itera...
function CEREAL_RAPIDJSON_FORCEINLINE (line 2171) | CEREAL_RAPIDJSON_FORCEINLINE bool IsIterativeParsingCompleteState(Iterat...
type GenericReader (line 2217) | typedef GenericReader<UTF8<>, UTF8<> > Reader;
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/schema.h
function namespace (line 77) | namespace internal {
function namespace (line 129) | namespace internal {
type typename (line 399) | typedef typename SchemaDocumentType::AllocatorType AllocatorType;
type typename (line 400) | typedef typename SchemaDocumentType::PointerType PointerType;
type typename (line 401) | typedef typename ValueType::EncodingType EncodingType;
type typename (line 402) | typedef typename EncodingType::Ch Ch;
type SchemaValidationContext (line 403) | typedef SchemaValidationContext<SchemaDocumentType> Context;
type Schema (line 404) | typedef Schema<SchemaDocumentType> SchemaType;
type GenericValue (line 405) | typedef GenericValue<EncodingType, AllocatorType> SValue;
type IValidationErrorHandler (line 406) | typedef IValidationErrorHandler<Schema> ErrorHandler;
type typename (line 447) | typedef typename ValueType::ConstValueIterator ConstValueIterator;
type typename (line 448) | typedef typename ValueType::ConstMemberIterator ConstMemberIterator;
type Hasher (line 466) | typedef Hasher<EncodingType, MemoryPoolAllocator<> > EnumHasherType;
function BeginValue (line 676) | bool BeginValue(Context& context) const {
function Null (line 785) | bool Null(Context& context) const {
function Bool (line 793) | bool Bool(Context& context, bool) const {
function Int (line 801) | bool Int(Context& context, int i) const {
function Uint (line 807) | bool Uint(Context& context, unsigned u) const {
function Int64 (line 813) | bool Int64(Context& context, int64_t i) const {
function Uint64 (line 819) | bool Uint64(Context& context, uint64_t u) const {
function Double (line 825) | bool Double(Context& context, double d) const {
function String (line 843) | bool String(Context& context, const Ch* str, SizeType length, bool) const {
function StartObject (line 871) | bool StartObject(Context& context) const {
function Key (line 892) | bool Key(Context& context, const Ch* str, SizeType len, bool) const {
function EndObject (line 941) | bool EndObject(Context& context, SizeType memberCount) const {
function StartArray (line 988) | bool StartArray(Context& context) const {
function EndArray (line 1000) | bool EndArray(Context& context, SizeType elementCount) const {
type SchemaValueType (line 1062) | enum SchemaValueType {
type internal (line 1074) | typedef internal::GenericRegex<EncodingType, AllocatorType> RegexType;
type std (line 1076) | typedef std::basic_regex<Ch> RegexType;
type RegexType (line 1078) | typedef char RegexType;
type SchemaArray (line 1081) | struct SchemaArray {
function ValueType (line 1098) | static const ValueType* GetMember(const ValueType& value, const ValueTyp...
function AssignIfExist (line 1103) | static void AssignIfExist(bool& out, const ValueType& value, const Value...
function AssignIfExist (line 1109) | static void AssignIfExist(SizeType& out, const ValueType& value, const V...
function AssignIfExist (line 1115) | void AssignIfExist(SchemaArray& out, SchemaDocumentType& schemaDocument,...
function IsPatternMatch (line 1145) | static bool IsPatternMatch(const RegexType* pattern, const Ch *str, Size...
function IsPatternMatch (line 1164) | static bool IsPatternMatch(const RegexType* pattern, const Ch *str, Size...
function FindPropertyIndex (line 1222) | bool FindPropertyIndex(const ValueType& name, SizeType* outIndex) const {
function CheckInt (line 1235) | bool CheckInt(Context& context, int64_t i) const {
function CheckUint (line 1283) | bool CheckUint(Context& context, uint64_t i) const {
function CheckDoubleMinimum (line 1331) | bool CheckDoubleMinimum(Context& context, double d) const {
function CheckDoubleMaximum (line 1339) | bool CheckDoubleMaximum(Context& context, double d) const {
function CheckDoubleMultipleOf (line 1347) | bool CheckDoubleMultipleOf(Context& context, double d) const {
function DisallowedType (line 1358) | void DisallowedType(Context& context, const ValueType& actualType) const {
type Property (line 1374) | struct Property {
type PatternProperty (line 1385) | struct PatternProperty {
function virtual (line 1485) | virtual ~IGenericRemoteSchemaDocumentProvider() {}
type IGenericRemoteSchemaDocumentProvider (line 1505) | typedef IGenericRemoteSchemaDocumentProvider<GenericSchemaDocument> IRem...
type Allocator (line 1506) | typedef Allocator AllocatorType;
type typename (line 1507) | typedef typename ValueType::EncodingType EncodingType;
type typename (line 1508) | typedef typename EncodingType::Ch Ch;
type internal (line 1509) | typedef internal::Schema<GenericSchemaDocument> SchemaType;
type GenericPointer (line 1510) | typedef GenericPointer<ValueType, Allocator> PointerType;
type GenericValue (line 1511) | typedef GenericValue<EncodingType, Allocator> URIType;
type SchemaRefEntry (line 1615) | struct SchemaRefEntry {
function CreateSchemaRecursive (line 1635) | void CreateSchemaRecursive(const SchemaType** schema, const PointerType&...
function CreateSchema (line 1652) | void CreateSchema(const SchemaType** schema, const PointerType& pointer,...
function HandleRefSchema (line 1664) | bool HandleRefSchema(const PointerType& source, const SchemaType** schem...
function SchemaType (line 1711) | const SchemaType* GetSchema(const PointerType& pointer) const {
function PointerType (line 1718) | PointerType GetPointer(const SchemaType* schema) const {
function SchemaType (line 1725) | const SchemaType* GetTypeless() const { return typeless_; }
type GenericSchemaDocument (line 1741) | typedef GenericSchemaDocument<Value> SchemaDocument;
type IGenericRemoteSchemaDocumentProvider (line 1743) | typedef IGenericRemoteSchemaDocumentProvider<SchemaDocument> IRemoteSche...
type typename (line 1771) | typedef typename SchemaDocumentType::PointerType PointerType;
type typename (line 1772) | typedef typename SchemaType::EncodingType EncodingType;
type typename (line 1773) | typedef typename SchemaType::SValue SValue;
type typename (line 1774) | typedef typename EncodingType::Ch Ch;
type GenericStringRef (line 1775) | typedef GenericStringRef<Ch> StringRefType;
type GenericValue (line 1776) | typedef GenericValue<EncodingType, StateAllocator> ValueType;
function Reset (line 1846) | void Reset() {
function Ch (line 1870) | const Ch* GetInvalidSchemaKeyword() const {
function NotMultipleOf (line 1884) | void NotMultipleOf(int64_t actual, const SValue& expected) {
function NotMultipleOf (line 1887) | void NotMultipleOf(uint64_t actual, const SValue& expected) {
function NotMultipleOf (line 1890) | void NotMultipleOf(double actual, const SValue& expected) {
function AboveMaximum (line 1893) | void AboveMaximum(int64_t actual, const SValue& expected, bool exclusive) {
function AboveMaximum (line 1897) | void AboveMaximum(uint64_t actual, const SValue& expected, bool exclusiv...
function AboveMaximum (line 1901) | void AboveMaximum(double actual, const SValue& expected, bool exclusive) {
function BelowMinimum (line 1905) | void BelowMinimum(int64_t actual, const SValue& expected, bool exclusive) {
function BelowMinimum (line 1909) | void BelowMinimum(uint64_t actual, const SValue& expected, bool exclusiv...
function BelowMinimum (line 1913) | void BelowMinimum(double actual, const SValue& expected, bool exclusive) {
function TooLong (line 1918) | void TooLong(const Ch* str, SizeType length, SizeType expected) {
function TooShort (line 1922) | void TooShort(const Ch* str, SizeType length, SizeType expected) {
function DoesNotMatch (line 1926) | void DoesNotMatch(const Ch* str, SizeType length) {
function DisallowedItem (line 1932) | void DisallowedItem(SizeType index) {
function TooFewItems (line 1937) | void TooFewItems(SizeType actualCount, SizeType expectedCount) {
function TooManyItems (line 1941) | void TooManyItems(SizeType actualCount, SizeType expectedCount) {
function DuplicateItems (line 1945) | void DuplicateItems(SizeType index1, SizeType index2) {
function TooManyProperties (line 1954) | void TooManyProperties(SizeType actualCount, SizeType expectedCount) {
function TooFewProperties (line 1958) | void TooFewProperties(SizeType actualCount, SizeType expectedCount) {
function StartMissingProperties (line 1962) | void StartMissingProperties() {
function AddMissingProperty (line 1965) | void AddMissingProperty(const SValue& name) {
function EndMissingProperties (line 1968) | bool EndMissingProperties() {
function PropertyViolations (line 1977) | void PropertyViolations(ISchemaValidator** subvalidators, SizeType count) {
function DisallowedProperty (line 1981) | void DisallowedProperty(const Ch* name, SizeType length) {
function StartDependencyErrors (line 1987) | void StartDependencyErrors() {
function StartMissingDependentProperties (line 1990) | void StartMissingDependentProperties() {
function AddMissingDependentProperty (line 1993) | void AddMissingDependentProperty(const SValue& targetName) {
function EndMissingDependentProperties (line 1996) | void EndMissingDependentProperties(const SValue& sourceName) {
function AddDependencySchemaError (line 2001) | void AddDependencySchemaError(const SValue& sourceName, ISchemaValidator...
function EndDependencyErrors (line 2005) | bool EndDependencyErrors() {
function DisallowedValue (line 2015) | void DisallowedValue() {
function StartDisallowedType (line 2019) | void StartDisallowedType() {
function AddExpectedType (line 2022) | void AddExpectedType(const typename SchemaType::ValueType& expectedType) {
function EndDisallowedType (line 2025) | void EndDisallowedType(const typename SchemaType::ValueType& actualType) {
function NotAllOf (line 2032) | void NotAllOf(ISchemaValidator** subvalidators, SizeType count) {
function NoneOf (line 2037) | void NoneOf(ISchemaValidator** subvalidators, SizeType count) {
function NotOneOf (line 2040) | void NotOneOf(ISchemaValidator** subvalidators, SizeType count) {
function Disallowed (line 2043) | void Disallowed() {
function Null (line 2104) | bool Null() { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Null, ...
function Bool (line 2105) | bool Bool(bool b) { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Bool, ...
function Int (line 2106) | bool Int(int i) { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int, ...
function Uint (line 2107) | bool Uint(unsigned u) { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint, ...
function Int64 (line 2108) | bool Int64(int64_t i) { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Int64, ...
function Uint64 (line 2109) | bool Uint64(uint64_t u) { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Uint64, ...
function Double (line 2110) | bool Double(double d) { CEREAL_RAPIDJSON_SCHEMA_HANDLE_VALUE_(Double, ...
function RawNumber (line 2111) | bool RawNumber(const Ch* str, SizeType length, bool copy)
function String (line 2113) | bool String(const Ch* str, SizeType length, bool copy)
function StartObject (line 2116) | bool StartObject() {
function Key (line 2122) | bool Key(const Ch* str, SizeType len, bool copy) {
function EndObject (line 2130) | bool EndObject(SizeType memberCount) {
function StartArray (line 2137) | bool StartArray() {
function EndArray (line 2143) | bool EndArray(SizeType elementCount) {
function virtual (line 2156) | virtual ISchemaValidator* CreateSchemaValidator(const SchemaType& root) {
function virtual (line 2164) | virtual void DestroySchemaValidator(ISchemaValidator* validator) {
function virtual (line 2170) | virtual void* CreateHasher() {
function virtual (line 2174) | virtual uint64_t GetHashCode(void* hasher) {
function virtual (line 2178) | virtual void DestroryHasher(void* hasher) {
function virtual (line 2184) | virtual void* MallocState(size_t size) {
function virtual (line 2188) | virtual void FreeState(void* p) {
type GenericValue (line 2194) | typedef GenericValue<UTF8<>, StateAllocator> HashCodeArray;
type internal (line 2195) | typedef internal::Hasher<EncodingType, StateAllocator> HasherType;
function BeginValue (line 2233) | bool BeginValue() {
function EndValue (line 2264) | bool EndValue() {
function AppendToken (line 2303) | void AppendToken(const Ch* str, SizeType len) {
function CEREAL_RAPIDJSON_FORCEINLINE (line 2320) | CEREAL_RAPIDJSON_FORCEINLINE void PushSchema(const SchemaType& schema) {...
function CEREAL_RAPIDJSON_FORCEINLINE (line 2322) | CEREAL_RAPIDJSON_FORCEINLINE void PopSchema() {
function AddErrorLocation (line 2331) | void AddErrorLocation(ValueType& result, bool parent) {
function AddError (line 2350) | void AddError(ValueType& keyword, ValueType& error) {
function MergeError (line 2369) | void MergeError(ValueType& other) {
type GenericSchemaValidator (line 2417) | typedef GenericSchemaValidator<SchemaDocument> SchemaValidator;
type typename (line 2441) | typedef typename InputStream::Ch Ch;
type GenericValue (line 2442) | typedef GenericValue<SourceEncoding, StackAllocator> ValueType;
function Ch (line 2477) | const Ch* GetInvalidSchemaKeyword() const { return invalidSchemaKeyword_; }
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/stream.h
function CEREAL_RAPIDJSON_NAMESPACE_BEGIN (line 22) | CEREAL_RAPIDJSON_NAMESPACE_BEGIN
function is_ (line 122) | is_(is) {}
function Ch (line 125) | Ch Take() { return is_.Take(); }
function Tell (line 126) | size_t Tell() { return is_.Tell(); }
function Ch (line 127) | Ch* PutBegin() { return is_.PutBegin(); }
function Put (line 128) | void Put(Ch ch) { is_.Put(ch); }
function Flush (line 129) | void Flush() { is_.Flush(); }
function PutEnd (line 130) | size_t PutEnd(Ch* ch) { return is_.PutEnd(ch); }
function Ch (line 133) | const Ch* Peek4() const { return is_.Peek4(); }
type typename (line 155) | typedef typename Encoding::Ch Ch;
function Ch (line 160) | Ch Take() { return *src_++; }
function Ch (line 163) | Ch* PutBegin() { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
function Put (line 164) | void Put(Ch) { CEREAL_RAPIDJSON_ASSERT(false); }
function Flush (line 165) | void Flush() { CEREAL_RAPIDJSON_ASSERT(false); }
function PutEnd (line 166) | size_t PutEnd(Ch*) { CEREAL_RAPIDJSON_ASSERT(false); return 0; }
type GenericStringStream (line 178) | typedef GenericStringStream<UTF8<> > StringStream;
type typename (line 189) | typedef typename Encoding::Ch Ch;
function Ch (line 194) | Ch Peek() { return *src_; }
function Ch (line 195) | Ch Take() { return *src_++; }
function Tell (line 196) | size_t Tell() { return static_cast<size_t>(src_ - head_); }
function Put (line 199) | void Put(Ch c) { CEREAL_RAPIDJSON_ASSERT(dst_ != 0); *dst_++ = c; }
function Ch (line 201) | Ch* PutBegin() { return dst_ = src_; }
function PutEnd (line 202) | size_t PutEnd(Ch* begin) { return static_cast<size_t>(dst_ - begin); }
function Flush (line 203) | void Flush() {}
function Ch (line 205) | Ch* Push(size_t count) { Ch* begin = dst_; dst_ += count; return begin; }
function Pop (line 206) | void Pop(size_t count) { dst_ -= count; }
type GenericInsituStringStream (line 219) | typedef GenericInsituStringStream<UTF8<> > InsituStringStream;
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidjson/writer.h
type WriteFlag (line 65) | enum WriteFlag {
function Reset (line 133) | void Reset(OutputStream& os) {
function SetMaxDecimalPlaces (line 172) | void SetMaxDecimalPlaces(int maxDecimalPlaces) {
function Null (line 181) | bool Null() { Prefix(kNullType); return EndValue(Write...
function Bool (line 182) | bool Bool(bool b) { Prefix(b ? kTrueType : kFalseType); return...
function Int (line 183) | bool Int(int i) { Prefix(kNumberType); return EndValue(Write...
function Uint (line 184) | bool Uint(unsigned u) { Prefix(kNumberType); return EndValue(Write...
function Int64 (line 185) | bool Int64(int64_t i64) { Prefix(kNumberType); return EndValue(Write...
function Uint64 (line 186) | bool Uint64(uint64_t u64) { Prefix(kNumberType); return EndValue(Write...
function Double (line 193) | bool Double(double d) { Prefix(kNumberType); return EndValue(Write...
function StartObject (line 215) | bool StartObject() {
function StartArray (line 239) | bool StartArray() {
function String (line 258) | bool String(const Ch* const& str) { return String(str, internal::StrLen(...
function Key (line 259) | bool Key(const Ch* const& str) { return Key(str, internal::StrLen(str)); }
function RawValue (line 271) | bool RawValue(const Ch* json, size_t length, Type type) {
function Flush (line 281) | void Flush() {
type Level (line 287) | struct Level {
function WriteNull (line 295) | bool WriteNull() {
function WriteBool (line 300) | bool WriteBool(bool b) {
function WriteInt (line 312) | bool WriteInt(int i) {
function WriteUint (line 321) | bool WriteUint(unsigned u) {
function WriteInt64 (line 330) | bool WriteInt64(int64_t i64) {
function WriteUint64 (line 339) | bool WriteUint64(uint64_t u64) {
function WriteDouble (line 348) | bool WriteDouble(double d) {
function WriteString (line 376) | bool WriteString(const Ch* str, SizeType length) {
function ScanWriteUnescapedString (line 450) | bool ScanWriteUnescapedString(GenericStringStream<SourceEncoding>& is, s...
function WriteStartObject (line 454) | bool WriteStartObject() { os_->Put('{'); return true; }
function WriteEndObject (line 455) | bool WriteEndObject() { os_->Put('}'); return true; }
function WriteStartArray (line 456) | bool WriteStartArray() { os_->Put('['); return true; }
function WriteEndArray (line 457) | bool WriteEndArray() { os_->Put(']'); return true; }
function WriteRawValue (line 459) | bool WriteRawValue(const Ch* json, size_t length) {
function Prefix (line 472) | void Prefix(Type type) {
function EndValue (line 493) | bool EndValue(bool ret) {
function WriteUint (line 521) | inline bool Writer<StringBuffer>::WriteUint(unsigned u) {
function WriteInt64 (line 529) | inline bool Writer<StringBuffer>::WriteInt64(int64_t i64) {
function WriteUint64 (line 537) | inline bool Writer<StringBuffer>::WriteUint64(uint64_t u) {
function WriteDouble (line 545) | inline bool Writer<StringBuffer>::WriteDouble(double d) {
FILE: examples/libraries/cereal-1.3.0/include/cereal/external/rapidxml/rapidxml.hpp
type cereal (line 30) | namespace cereal {
type rapidxml (line 31) | namespace rapidxml
class parse_error (line 74) | class parse_error: public std::exception
method parse_error (line 80) | parse_error(const char *what_, void *where_)
method CEREAL_NOEXCEPT (line 88) | CEREAL_NOEXCEPT override
method Ch (line 97) | Ch *where() const
class xml_node (line 142) | class xml_node
method xml_node (line 914) | xml_node(node_type type_)
method node_type (line 926) | node_type type() const
method type (line 1078) | void type(node_type type_)
method prepend_node (line 1089) | void prepend_node(xml_node<Ch> *child)
method append_node (line 1110) | void append_node(xml_node<Ch> *child)
method insert_node (line 1132) | void insert_node(xml_node<Ch> *where, xml_node<Ch> *child)
method remove_first_node (line 1153) | void remove_first_node()
method remove_last_node (line 1168) | void remove_last_node()
method remove_node (line 1184) | void remove_node(xml_node<Ch> *where)
method remove_all_nodes (line 1201) | void remove_all_nodes()
method prepend_attribute (line 1210) | void prepend_attribute(xml_attribute<Ch> *attribute)
method append_attribute (line 1230) | void append_attribute(xml_attribute<Ch> *attribute)
method insert_attribute (line 1252) | void insert_attribute(xml_attribute<Ch> *where, xml_attribute<Ch> ...
method remove_first_attribute (line 1273) | void remove_first_attribute()
method remove_last_attribute (line 1290) | void remove_last_attribute()
method remove_attribute (line 1306) | void remove_attribute(xml_attribute<Ch> *where)
method remove_all_attributes (line 1322) | void remove_all_attributes()
class xml_attribute (line 143) | class xml_attribute
method xml_attribute (line 823) | xml_attribute()
class xml_document (line 144) | class xml_document
method xml_document (line 1377) | xml_document()
method parse (line 1394) | void parse(Ch *text)
method clear (line 1428) | void clear()
type whitespace_pred (line 1441) | struct whitespace_pred
method test (line 1443) | static unsigned char test(Ch ch)
type node_name_pred (line 1450) | struct node_name_pred
method test (line 1452) | static unsigned char test(Ch ch)
type attribute_name_pred (line 1459) | struct attribute_name_pred
method test (line 1461) | static unsigned char test(Ch ch)
type text_pred (line 1468
Copy disabled (too large)
Download .json
Condensed preview — 1954 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (20,586K chars).
[
{
"path": "README.md",
"chars": 1275,
"preview": "# C++20 Fundamentals LiveLessons Code Examples\nSource code examples for our **C++20 Fundamentals LiveLessons** Videos.\n\n"
},
{
"path": "examples/docker/gcc13/dockerfile",
"chars": 241,
"preview": "FROM ubuntu:20.04\r\nRUN apt-get update -y\r\nRUN apt-get install -y build-essential wget\r\nRUN wget --quiet --content-dispos"
},
{
"path": "examples/lesson01/GuessNumber.cpp",
"chars": 2837,
"preview": "// Randomly generate numbers between 1 and 1000 for user to guess.\n#include <iostream>\n#include <random> // contains C++"
},
{
"path": "examples/lesson02/fig02_01.cpp",
"chars": 1417,
"preview": "// fig02_01.cpp\r\n// Text-printing program.\r\n#include <iostream> // enables program to output data to the screen\r\n\r\n// fu"
},
{
"path": "examples/lesson02/fig02_02.cpp",
"chars": 1387,
"preview": "// fig02_02.cpp\r\n// Displaying a line of text with multiple statements.\r\n#include <iostream> // enables program to outpu"
},
{
"path": "examples/lesson02/fig02_03.cpp",
"chars": 1360,
"preview": "// fig02_03.cpp\r\n// Displayings multiple lines of text with a single statement.\r\n#include <iostream> // enables program "
},
{
"path": "examples/lesson02/fig02_04.cpp",
"chars": 1961,
"preview": "// fig02_04.cpp\r\n// Addition program that displays the sum of two integers.\r\n#include <iostream> // enables program to p"
},
{
"path": "examples/lesson02/fig02_05.cpp",
"chars": 2237,
"preview": "// fig02_05.cpp\r\n// Comparing integers using if statements, relational operators\r\n// and equality operators.\r\n#include <"
},
{
"path": "examples/lesson02/fig02_06.cpp",
"chars": 2393,
"preview": "// fig02_06.cpp\r\n// Standard library string class test program. \r\n#include <iostream>\r\n#include <string> \r\nusing namespa"
},
{
"path": "examples/lesson03/fig03_01.cpp",
"chars": 1973,
"preview": "// fig03_01.cpp\r\n// Solving the class-average problem using counter-controlled iteration.\r\n#include <iostream>\r\nusing na"
},
{
"path": "examples/lesson03/fig03_02.cpp",
"chars": 2520,
"preview": "// fig03_02.cpp\r\n// Solving the class-average problem using sentinel-controlled iteration. \r\n#include <iostream>\r\n#inclu"
},
{
"path": "examples/lesson03/fig03_03.cpp",
"chars": 2168,
"preview": "// fig03_03.cpp\r\n// Analysis of examination results using nested control statements.\r\n#include <iostream>\r\nusing namespa"
},
{
"path": "examples/lesson03/fig03_04.cpp",
"chars": 1807,
"preview": "// fig03_04.cpp\r\n// Prefix increment and postfix increment operators.\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint "
},
{
"path": "examples/lesson03/fig03_05.cpp",
"chars": 2206,
"preview": "// fig03_05.cpp\r\n// Conveniently creating and manipulating super-sized integers\r\n// with objects of the Boost Multipreci"
},
{
"path": "examples/lesson04/decimalformatter.h",
"chars": 975,
"preview": "// decimalformatter.h\r\n// Custom std::formatter that formats a \r\n// boost::multiprecision::cpp_dec_float_50 as a std::st"
},
{
"path": "examples/lesson04/decimalformatter_fmt.h",
"chars": 1024,
"preview": "// decimalformatter.h\r\n// Custom fmt::formatter that formats a \r\n// boost::multiprecision::cpp_dec_float_50 as a std::st"
},
{
"path": "examples/lesson04/ex04_06.cpp",
"chars": 1293,
"preview": "// ex04_06.cpp\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint main() {\r\n for (int i{1}; i <= 10; i++) {\r\n for "
},
{
"path": "examples/lesson04/fig04_01.cpp",
"chars": 1468,
"preview": "// fig04_01.cpp\r\n// Counter-controlled iteration with the while iteration statement.\r\n#include <iostream>\r\nusing namespa"
},
{
"path": "examples/lesson04/fig04_02.cpp",
"chars": 1444,
"preview": "// fig04_02.cpp\r\n// Counter-controlled iteration with the for iteration statement.\r\n#include <iostream>\r\nusing namespace"
},
{
"path": "examples/lesson04/fig04_03.cpp",
"chars": 1447,
"preview": "// fig04_03.cpp\n// Summing integers with the for statement; introducing text formatting.\n#include <format> \n#include <io"
},
{
"path": "examples/lesson04/fig04_03fmt.cpp",
"chars": 1499,
"preview": "// fig04_03.cpp\n// Summing integers with the for statement; introducing text formatting.\n#include <fmt/format.h> // C++2"
},
{
"path": "examples/lesson04/fig04_04.cpp",
"chars": 2143,
"preview": "// fig04_04.cpp\r\n// Compound-interest calculations with for.\r\n#include <format> \r\n#include <iostream>\r\n#include <cmath> "
},
{
"path": "examples/lesson04/fig04_04fmt.cpp",
"chars": 2210,
"preview": "// fig04_04.cpp\r\n// Compound-interest calculations with for.\r\n#include <fmt/format.h> // C++20: This will be #include <f"
},
{
"path": "examples/lesson04/fig04_05.cpp",
"chars": 1349,
"preview": "// fig04_05.cpp\r\n// do...while iteration statement.\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint main() {\r\n int c"
},
{
"path": "examples/lesson04/fig04_06.cpp",
"chars": 4047,
"preview": "// fig04_06.cpp\r\n// Using a switch statement to count letter grades.\r\n#include <format>\r\n#include <iostream>\r\nusing name"
},
{
"path": "examples/lesson04/fig04_06fmt.cpp",
"chars": 4110,
"preview": "// fig04_06.cpp\r\n// Using a switch statement to count letter grades.\r\n#include <fmt/format.h> // C++20: This will be #in"
},
{
"path": "examples/lesson04/fig04_07.cpp",
"chars": 1556,
"preview": "// fig04_07.cpp\r\n// if statements with initializers.\r\n#include <format> \r\n#include <iostream>\r\nusing namespace std;\r\n\r\ni"
},
{
"path": "examples/lesson04/fig04_07_with_error.cpp",
"chars": 1564,
"preview": "// fig04_07_with_error.cpp\r\n// C++17 if statements with initializers.\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint "
},
{
"path": "examples/lesson04/fig04_07fmt.cpp",
"chars": 1623,
"preview": "// fig04_07.cpp\r\n// if statements with initializers.\r\n#include <fmt/format.h> // C++20: This will be #include <format> \r"
},
{
"path": "examples/lesson04/fig04_08.cpp",
"chars": 1521,
"preview": "// fig04_08.cpp\r\n// break statement exiting a for statement.\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint main() {\r"
},
{
"path": "examples/lesson04/fig04_09.cpp",
"chars": 1489,
"preview": "// fig04_09.cpp\r\n// continue statement terminating an iteration of a for statement.\r\n#include <iostream>\r\nusing namespac"
},
{
"path": "examples/lesson04/fig04_10.cpp",
"chars": 2008,
"preview": "// fig04_10.cpp\r\n// Logical operators.\r\n#include <format>\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint main() {\r\n "
},
{
"path": "examples/lesson04/fig04_11.cpp",
"chars": 3272,
"preview": "// fig04_11.cpp\r\n// Using the miniz-cpp header-only library to write and read a ZIP file.\r\n#include <iostream>\r\n#include"
},
{
"path": "examples/lesson04/fig04_12/fig04_12.cpp",
"chars": 2031,
"preview": "// fig04_12.cpp\r\n// Compound-interest example with C++20 text formatting.\r\n#include <iostream>\r\n#include <cmath> // for "
},
{
"path": "examples/lesson04/fig04_12/fmt/core.h",
"chars": 59182,
"preview": "// Formatting library for C++ - the core API\n//\n// Copyright (c) 2012 - present, Victor Zverovich\n// All rights reserved"
},
{
"path": "examples/lesson04/fig04_12/fmt/format-inl.h",
"chars": 51059,
"preview": "// Formatting library for C++ - implementation\n//\n// Copyright (c) 2012 - 2016, Victor Zverovich\n// All rights reserved."
},
{
"path": "examples/lesson04/fig04_12/fmt/format.h",
"chars": 119755,
"preview": "/*\n Formatting library for C++\n\n Copyright (c) 2012 - present, Victor Zverovich\n\n Permission is hereby granted, free of "
},
{
"path": "examples/lesson04/fig04_12/format.cc",
"chars": 6505,
"preview": "// Formatting library for C++\n//\n// Copyright (c) 2012 - 2016, Victor Zverovich\n// All rights reserved.\n//\n// For the li"
},
{
"path": "examples/lesson04/fig04_17.cpp",
"chars": 1948,
"preview": "// fig04_17.cpp\r\n// Compound-interest example with boost::multiprecision::cpp_dec_float_50. \r\n#include <boost/multipreci"
},
{
"path": "examples/lesson04/fig04_17fmt.cpp",
"chars": 2019,
"preview": "// fig04_17.cpp\r\n// Compound-interest example with boost::multiprecision::cpp_dec_float_50. \r\n#include <boost/multipreci"
},
{
"path": "examples/lesson05/cipher.h",
"chars": 7815,
"preview": "// Fig. 9.37: cipher.h\r\n// Vigenre cipher implementation. \r\n#pragma once\r\n#include <algorithm>\r\n#include <array>\r\n#inclu"
},
{
"path": "examples/lesson05/ex05_31.cpp",
"chars": 1609,
"preview": "// ex05_31.cpp\r\n// What does this program do?\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint mystery(int, int); // fu"
},
{
"path": "examples/lesson05/fig05_01.cpp",
"chars": 1946,
"preview": "// fig05_01.cpp\r\n// maximum function with a function prototype.\r\n#include <iostream>\r\n\r\nusing namespace std;\r\n\r\nint maxi"
},
{
"path": "examples/lesson05/fig05_02.cpp",
"chars": 1647,
"preview": "// fig05_02.cpp\r\n// Producing random integers in the range 1 through 6.\r\n#include <iostream>\r\n#include <random> // conta"
},
{
"path": "examples/lesson05/fig05_03.cpp",
"chars": 3008,
"preview": "// fig05_03.cpp\r\n// Rolling a six-sided die randomly 60,000,000 times.\r\n#include <format>\r\n#include <iostream>\r\n#include"
},
{
"path": "examples/lesson05/fig05_04.cpp",
"chars": 1641,
"preview": "// fig05_04.cpp\r\n// Randomizing the die-rolling program.\r\n#include <iostream>\r\n#include <random>\r\n\r\nusing namespace std;"
},
{
"path": "examples/lesson05/fig05_05.cpp",
"chars": 3410,
"preview": "// fig05_05.cpp\r\n// Craps simulation.\r\n#include <format>\r\n#include <iostream>\r\n#include <random> \r\nusing namespace std;\r"
},
{
"path": "examples/lesson05/fig05_06.cpp",
"chars": 1583,
"preview": "// fig05_06.cpp\r\n// square function used to demonstrate the function \r\n// call stack and activation records.\r\n#include <"
},
{
"path": "examples/lesson05/fig05_07.cpp",
"chars": 1895,
"preview": "// fig05_07.cpp\r\n// inline function that calculates the volume of a cube.\r\n#include <iostream> \r\nusing namespace std;\r\n\r"
},
{
"path": "examples/lesson05/fig05_08.cpp",
"chars": 2479,
"preview": "// fig05_08.cpp\r\n// Passing arguments by value and by reference.\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint squar"
},
{
"path": "examples/lesson05/fig05_09.cpp",
"chars": 2156,
"preview": "// fig05_09.cpp\r\n// Using default arguments.\r\n#include <iostream>\r\nusing namespace std;\r\n\r\n// function prototype that sp"
},
{
"path": "examples/lesson05/fig05_10.cpp",
"chars": 1728,
"preview": "// fig05_10.cpp\r\n// Overloaded square functions.\r\n#include <iostream>\r\nusing namespace std;\r\n\r\n// function square for in"
},
{
"path": "examples/lesson05/fig05_11.cpp",
"chars": 1618,
"preview": "// fig05_11.cpp\r\n// Name mangling to enable type-safe linkage.\r\n\r\n// function square for int values\r\nint square(int x) {"
},
{
"path": "examples/lesson05/fig05_12.cpp",
"chars": 1611,
"preview": "// fig05_12.cpp\r\n// Overloaded square functions.\r\n#include <iostream>\r\nusing namespace std;\r\n\r\n// function square for in"
},
{
"path": "examples/lesson05/fig05_13.cpp",
"chars": 2154,
"preview": "// fig05_13.cpp\r\n// Function template maximum test program.\r\n#include <iostream>\r\n#include \"maximum.h\" // include defini"
},
{
"path": "examples/lesson05/fig05_14.cpp",
"chars": 2232,
"preview": "// fig05_14.cpp\r\n// Recursive function factorial.\r\n#include <boost/multiprecision/cpp_int.hpp>\r\n#include <format>\r\n#incl"
},
{
"path": "examples/lesson05/fig05_15.cpp",
"chars": 2205,
"preview": "// fig05_15.cpp\r\n// Recursive function fibonacci.\r\n#include <format> \r\n#include <iostream>\r\nusing namespace std;\r\n\r\nlon"
},
{
"path": "examples/lesson05/fig05_16.cpp",
"chars": 3230,
"preview": "// fig05_16.cpp\r\n// Scoping example.\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nvoid useLocal(); // function prototyp"
},
{
"path": "examples/lesson05/fig05_17.cpp",
"chars": 1479,
"preview": "// fig05_17.cpp\r\n// Unary scope resolution operator.\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nconst int number{7}; "
},
{
"path": "examples/lesson05/fig05_18.cpp",
"chars": 1972,
"preview": "// fig05_18.cpp\r\n// Encrypting and decrypting text with a Vigenre cipher. \r\n#include \"cipher.h\"\r\n#include <iostream>\r\n#i"
},
{
"path": "examples/lesson05/fig05_19.cpp",
"chars": 1233,
"preview": "// fig05_19.cpp\n// C++17 [[nodiscard]] attribute.\n\n[[nodiscard]]\nint cube(int x) {\n return x * x * x;\n}\n\nint main() {\n"
},
{
"path": "examples/lesson05/fig05_20.cpp",
"chars": 1972,
"preview": "// fig15_20.cpp\r\n// Encrypting and decrypting text with a Vigenre cipher. \r\n#include \"cipher.h\"\r\n#include <iostream>\r\n#i"
},
{
"path": "examples/lesson05/maximum.h",
"chars": 1882,
"preview": "// Fig. 5.12: maximum.h\r\n// Function template maximum header.\r\ntemplate <typename T> // or template <class T> \r\nT "
},
{
"path": "examples/lesson06/fig06_01.cpp",
"chars": 2063,
"preview": "// fig06_01.cpp\r\n// Initializing an array's elements to zeros and printing the array.\r\n#include <format>\r\n#include <iost"
},
{
"path": "examples/lesson06/fig06_02.cpp",
"chars": 1775,
"preview": "// fig06_02.cpp\r\n// Initializing an array in a declaration.\r\n#include <format>\r\n#include <iostream>\r\n#include <array>\r\n\r"
},
{
"path": "examples/lesson06/fig06_03.cpp",
"chars": 2161,
"preview": "// fig06_03.cpp\r\n// Using range-based for.\r\n#include <format>\r\n#include <iostream>\r\n#include <array>\r\n\r\nint main() {\r\n "
},
{
"path": "examples/lesson06/fig06_04.cpp",
"chars": 1704,
"preview": "// fig06_04.cpp\r\n// Set array values to the even integers from 2 to 10.\r\n#include <format>\r\n#include <iostream>\r\n#includ"
},
{
"path": "examples/lesson06/fig06_05.cpp",
"chars": 1496,
"preview": "// fig06_05.cpp\r\n// Compute the sum of an array's elements.\r\n#include <format>\r\n#include <iostream>\r\n#include <array>\r\n\r"
},
{
"path": "examples/lesson06/fig06_06.cpp",
"chars": 1951,
"preview": "// fig06_06.cpp\r\n// Printing a student grade distribution as a primitive bar chart.\r\n#include <format>\r\n#include <iostre"
},
{
"path": "examples/lesson06/fig06_07.cpp",
"chars": 2026,
"preview": "// fig06_07.cpp\r\n// Die-rolling program using an array instead of switch.\r\n#include <format>\r\n#include <iostream>\r\n#incl"
},
{
"path": "examples/lesson06/fig06_08.cpp",
"chars": 1989,
"preview": "// fig06_08.cpp\r\n// Poll analysis program.\r\n#include <format>\r\n#include <iostream>\r\n#include <array>\r\n\r\nint main() {\r\n "
},
{
"path": "examples/lesson06/fig06_09.cpp",
"chars": 2422,
"preview": "// fig06_09.cpp\r\n// Sorting and searching arrays.\r\n#include <array>\r\n#include <algorithm> // contains sort and binary_se"
},
{
"path": "examples/lesson06/fig06_10.cpp",
"chars": 2065,
"preview": "// fig06_10.cpp\r\n// Initializing multidimensional arrays.\r\n#include <iostream> \r\n#include <array> \r\n\r\nconstexpr size_t r"
},
{
"path": "examples/lesson06/fig06_11.cpp",
"chars": 1444,
"preview": "// fig06_11.cpp\r\n// Compute the sum of the elements of an array using accumulate.\r\n#include <array>\r\n#include <format>\r\n"
},
{
"path": "examples/lesson06/fig06_12.cpp",
"chars": 1712,
"preview": "// fig06_12.cpp\r\n// Compute the product of an array's elements using accumulate.\r\n#include <array>\r\n#include <format>\r\n#"
},
{
"path": "examples/lesson06/fig06_13.cpp",
"chars": 2993,
"preview": "// fig06_13.cpp\r\n// Functional-style programming with C++20 ranges and views.\r\n#include <array>\r\n#include <format>\r\n#inc"
},
{
"path": "examples/lesson06/fig06_14.cpp",
"chars": 4543,
"preview": "// fig06_14.cpp\r\n// Demonstrating C++ standard library class template vector.\r\n#include <iostream>\r\n#include <vector> "
},
{
"path": "examples/lesson07/fig07_01.cpp",
"chars": 1510,
"preview": "// fig07_01.cpp\r\n// Pointer operators & and *.\r\n#include <iostream>\r\nusing namespace std;\r\n\r\nint main() {\r\n constexpr "
},
{
"path": "examples/lesson07/fig07_02.cpp",
"chars": 1653,
"preview": "// fig07_02.cpp\r\n// Pass-by-value used to cube a variable's value.\r\n#include <format>\r\n#include <iostream>\r\n\r\nint cubeBy"
},
{
"path": "examples/lesson07/fig07_03.cpp",
"chars": 1693,
"preview": "// fig07_03.cpp\r\n// Pass-by-reference with a pointer argument used to cube a \r\n// variable's value.\r\n#include <format>\r\n"
},
{
"path": "examples/lesson07/fig07_06.cpp",
"chars": 1976,
"preview": "// fig07_06.cpp\n// C++20: Creating std::arrays with to_array.\n#include <format>\n#include <iostream>\n#include <array>\n\nin"
},
{
"path": "examples/lesson07/fig07_07.cpp",
"chars": 1300,
"preview": "// fig07_07.cpp\r\n// Attempting to modify data through a \r\n// nonconstant pointer to constant data.\r\n\r\nint main() {\r\n i"
},
{
"path": "examples/lesson07/fig07_08.cpp",
"chars": 1525,
"preview": "// fig07_08.cpp\n// Attempting to modify a constant pointer to nonconstant data.\n\nint main() {\n int x, y;\n\n // ptr is"
},
{
"path": "examples/lesson07/fig07_09.cpp",
"chars": 1593,
"preview": "// fig07_09.cpp\r\n// Attempting to modify a constant pointer to constant data.\r\n#include <iostream>\r\nusing namespace std;"
},
{
"path": "examples/lesson07/fig07_10.cpp",
"chars": 1680,
"preview": "// fig07_10.cpp\r\n// Sizeof operator when used on a built-in array's name\r\n// returns the number of bytes in the built-in"
},
{
"path": "examples/lesson07/fig07_11.cpp",
"chars": 2717,
"preview": "// fig07_11.cpp\r\n// sizeof operator used to determine standard data type sizes.\r\n#include <format>\r\n#include <iostream>\r"
},
{
"path": "examples/lesson07/fig07_12.cpp",
"chars": 3934,
"preview": "// fig07_12.cpp\n// C++20 spans: Creating views into containers.\n#include <array>\n#include <format>\n#include <iostream>\n#"
},
{
"path": "examples/lesson07/fig07_13.cpp",
"chars": 1354,
"preview": "// fig07_13.cpp\n// Reading in command-line arguments.\n#include <format>\n#include <iostream>\n\nint main(int argc, char* ar"
},
{
"path": "examples/lesson07/fig07_14.cpp",
"chars": 1988,
"preview": "// fig07_14.cpp\n// C++20: Creating std::arrays from string literals with to_array.\n#include <format>\n#include <iostream>"
},
{
"path": "examples/lesson08/accounts.csv",
"chars": 107,
"preview": "account,name,balance\r\n100,Devi,24.98\r\n200,Taylor,345.67\r\n300,Huber,0.0\r\n400,Karimov,-42.16\r\n500,Sosa,224.62"
},
{
"path": "examples/lesson08/fig08_01.cpp",
"chars": 2178,
"preview": "// fig08_01.cpp\r\n// Demonstrating string assignment and concatenation.\r\n#include <format> \r\n#include <iostream>\r\n#includ"
},
{
"path": "examples/lesson08/fig08_02.cpp",
"chars": 2292,
"preview": "// fig08_02.cpp\r\n// Comparing strings.\r\n#include <format>\r\n#include <iostream>\r\n#include <string>\r\n\r\nvoid displayResult("
},
{
"path": "examples/lesson08/fig08_03.cpp",
"chars": 1320,
"preview": "// fig08_03.cpp\r\n// Demonstrating string member function substr.\r\n#include <iostream>\r\n#include <string>\r\n\r\nint main() {"
},
{
"path": "examples/lesson08/fig08_04.cpp",
"chars": 1460,
"preview": "// fig08_04.cpp\r\n// Using the swap function to swap two strings.\r\n#include <format> \r\n#include <iostream>\r\n#include <str"
},
{
"path": "examples/lesson08/fig08_05.cpp",
"chars": 2501,
"preview": "// fig08_05.cpp\r\n// Printing string characteristics.\r\n#include <format> \r\n#include <iostream>\r\n#include <string>\r\n\r\n// d"
},
{
"path": "examples/lesson08/fig08_06.cpp",
"chars": 2582,
"preview": "// fig08_06.cpp\r\n// Demonstrating the string find member functions.\r\n#include <format> \r\n#include <iostream>\r\n#include <"
},
{
"path": "examples/lesson08/fig08_07.cpp",
"chars": 2445,
"preview": "// fig08_07.cpp\r\n// Demonstrating string member functions erase and replace.\r\n#include <format> \r\n#include <iostream>\r\n#"
},
{
"path": "examples/lesson08/fig08_08.cpp",
"chars": 1623,
"preview": "// fig08_08.cpp\r\n// Demonstrating std::string insert member functions.\r\n#include <format> \r\n#include <iostream>\r\n#includ"
},
{
"path": "examples/lesson08/fig08_09.cpp",
"chars": 2449,
"preview": "// fig08_09.cpp\r\n// Demonstrating string_view.\r\n#include <format> \r\n#include <iostream>\r\n#include <string>\r\n#include <st"
},
{
"path": "examples/lesson08/fig08_10.cpp",
"chars": 1968,
"preview": "// fig08_10.cpp\r\n// Creating a sequential file.\r\n#include <cstdlib> // exit function prototype \r\n#include <"
},
{
"path": "examples/lesson08/fig08_11.cpp",
"chars": 1862,
"preview": "// fig08_11.cpp\r\n// Reading and printing a sequential file.\r\n#include <cstdlib> \r\n#include <format> \r\n#include <fstream>"
},
{
"path": "examples/lesson08/fig08_12.cpp",
"chars": 2017,
"preview": "// fig08_12.cpp\r\n// Using an ostringstream object.\r\n#include <iostream>\r\n#include <sstream> // header for string stream "
},
{
"path": "examples/lesson08/fig08_13.cpp",
"chars": 1832,
"preview": "// fig08_13.cpp\r\n// Demonstrating input from an istringstream object.\r\n#include <format> \r\n#include <iostream>\r\n#include"
},
{
"path": "examples/lesson08/fig08_14.cpp",
"chars": 1793,
"preview": "// fig08_14.cpp\r\n// Reading from a CSV file.\r\n#include <format> \r\n#include <iostream>\r\n#include <rapidcsv.h> \r\n#include "
},
{
"path": "examples/lesson08/fig08_15.cpp",
"chars": 5967,
"preview": "// fig08_15.cpp\r\n// Reading the Titanic dataset from a CSV file, then analyzing it.\r\n#include <format> \r\n#include <algor"
},
{
"path": "examples/lesson08/fig08_16.cpp",
"chars": 3853,
"preview": "// fig08_16.cpp\r\n// Matching entire strings to regular expressions.\r\n#include <format> \r\n#include <iostream>\r\n#include <"
},
{
"path": "examples/lesson08/fig08_17.cpp",
"chars": 1496,
"preview": "// fig08_17.cpp\r\n// Regular expression replacements.\r\n#include <format> \r\n#include <iostream>\r\n#include <regex>\r\n#includ"
},
{
"path": "examples/lesson08/fig08_18.cpp",
"chars": 2458,
"preview": "// fig08_18.cpp\r\n// Matching patterns throughout a string.\r\n#include <format> \r\n#include <iostream>\r\n#include <regex>\r\n#"
},
{
"path": "examples/lesson08/format.cc",
"chars": 6505,
"preview": "// Formatting library for C++\n//\n// Copyright (c) 2012 - 2016, Victor Zverovich\n// All rights reserved.\n//\n// For the li"
},
{
"path": "examples/lesson08/titanic.csv",
"chars": 117743,
"preview": "\"pclass\",\"survived\",\"name\",\"sex\",\"age\",\"sibsp\",\"parch\",\"ticket\",\"fare\",\"cabin\",\"embarked\",\"boat\",\"body\",\"home.dest\"\n1,1,"
},
{
"path": "examples/lesson09/fig09_01-02/Account.h",
"chars": 1734,
"preview": "// Fig. 9.2: Account.h\r\n// Account class with a data member and\r\n// member functions to set and get its value.\r\n#include"
},
{
"path": "examples/lesson09/fig09_01-02/AccountTest.cpp",
"chars": 1861,
"preview": "// Fig. 9.1: AccountTest.cpp\r\n// Creating and manipulating an Account object.\r\n#include <format>\r\n#include <iostream>\r\n#"
},
{
"path": "examples/lesson09/fig09_03-04/Account.h",
"chars": 1780,
"preview": "// Fig. 9.3: Account.h\r\n// Account class with a constructor that initializes the account name.\r\n#include <string>\r\n#incl"
},
{
"path": "examples/lesson09/fig09_03-04/AccountTest.cpp",
"chars": 1602,
"preview": "// Fig. 9.4: AccountTest.cpp\r\n// Using the Account constructor to initialize the m_name \r\n// data member when each Accou"
},
{
"path": "examples/lesson09/fig09_05-06/Account.h",
"chars": 2237,
"preview": "// Fig. 9.5: Account.h\r\n// Account class with m_name and m_balance data members, and a \r\n// constructor and deposit func"
},
{
"path": "examples/lesson09/fig09_05-06/AccountTest.cpp",
"chars": 2670,
"preview": "// Fig. 9.6: AccountTest.cpp\r\n// Displaying and updating Account balances.\r\n#include <format>\r\n#include <iostream>\r\n#inc"
},
{
"path": "examples/lesson09/fig09_07-09/Time.cpp",
"chars": 2187,
"preview": "// Fig. 9.8: Time.cpp\r\n// Time class member-function definitions. \r\n#include <format>\r\n#include <stdexcept> // for inval"
},
{
"path": "examples/lesson09/fig09_07-09/Time.h",
"chars": 1634,
"preview": "// Fig. 9.7: Time.h\r\n// Time class definition. \r\n// Member functions are defined in Time.cpp \r\n#pragma"
},
{
"path": "examples/lesson09/fig09_07-09/fig09_09.cpp",
"chars": 2258,
"preview": "// fig09_09.cpp\r\n// Program to test class Time. \r\n// NOTE: This file must be linked with Time.cpp. \r"
},
{
"path": "examples/lesson09/fig09_10-12/Time.cpp",
"chars": 2945,
"preview": "// Fig. 9.11: Time.cpp\r\n// Member-function definitions for class Time.\r\n#include <format>\r\n#include <stdexcept>\r\n#includ"
},
{
"path": "examples/lesson09/fig09_10-12/Time.h",
"chars": 2156,
"preview": "// Fig. 9.10: Time.h\r\n// Time class containing a constructor with default arguments.\r\n// Member functions defined in Tim"
},
{
"path": "examples/lesson09/fig09_10-12/fig09_12.cpp",
"chars": 2412,
"preview": "// fig09_12.cpp \r\n// Constructor with default arguments.\r\n#include <format>\r\n#include <iostream>\r\n#include <stdexcept>\r\n"
},
{
"path": "examples/lesson09/fig09_13-15/CreateAndDestroy.cpp",
"chars": 1862,
"preview": "// Fig. 9.14: CreateAndDestroy.cpp\r\n// CreateAndDestroy class member-function definitions.\r\n#include <format>\r\n#include "
},
{
"path": "examples/lesson09/fig09_13-15/CreateAndDestroy.h",
"chars": 1583,
"preview": "// Fig. 9.13: CreateAndDestroy.h\r\n// CreateAndDestroy class definition.\r\n// Member functions defined in CreateAndDestroy"
},
{
"path": "examples/lesson09/fig09_13-15/fig09_15.cpp",
"chars": 2149,
"preview": "// fig09_15.cpp\r\n// Order in which constructors and \r\n// destructors are called.\r\n#include <iostream>\r\n#include \"CreateA"
},
{
"path": "examples/lesson09/fig09_16-18/Time.cpp",
"chars": 2043,
"preview": "// Fig. 9.17: Time.cpp\r\n// Time class member-function definitions.\r\n#include <stdexcept>\r\n#include \"Time.h\" // include d"
},
{
"path": "examples/lesson09/fig09_16-18/Time.h",
"chars": 1472,
"preview": "// Fig. 9.16: Time.h\r\n// Time class definition.\r\n// Member functions defined in Time.cpp\r\n\r\n// prevent multiple inclusio"
},
{
"path": "examples/lesson09/fig09_16-18/fig09_18.cpp",
"chars": 2016,
"preview": "// fig09_18.cpp\r\n// public member function that\r\n// returns a reference to private data.\r\n#include <iostream>\r\n#include "
},
{
"path": "examples/lesson09/fig09_19-21/Date.cpp",
"chars": 1575,
"preview": "// Fig. 9.20: Date.cpp\r\n// Date class member-function definitions.\r\n#include <format>\r\n#include <string>\r\n#include \"Date"
},
{
"path": "examples/lesson09/fig09_19-21/Date.h",
"chars": 1438,
"preview": "// Fig. 9.19: Date.h\r\n// Date class declaration. Member functions are defined in Date.cpp.\r\n#pragma once // prevent mult"
},
{
"path": "examples/lesson09/fig09_19-21/fig09_21.cpp",
"chars": 1653,
"preview": "// fig09_21.cpp \r\n// Demonstrating that class objects can be assigned\r\n// to each other using the default assignment ope"
},
{
"path": "examples/lesson09/fig09_22/Time.cpp",
"chars": 2937,
"preview": "// Fig. 9.11: Time.cpp\r\n// Member-function definitions for class Time.\r\n#include <format>\r\n#include <stdexcept>\r\n#includ"
},
{
"path": "examples/lesson09/fig09_22/Time.h",
"chars": 2150,
"preview": "// Fig. 9.10: Time.h\r\n// Time class containing a constructor with default arguments.\r\n// Member functions defined in Tim"
},
{
"path": "examples/lesson09/fig09_22/fig09_22.cpp",
"chars": 1698,
"preview": "// fig09_22.cpp\r\n// const objects and const member functions.\r\n#include \"Time.h\" // include Time class definition\r\n\r\nint"
},
{
"path": "examples/lesson09/fig09_23-27/Date.cpp",
"chars": 2919,
"preview": "// Fig. 9.24: Date.cpp\r\n// Date class member-function definitions.\r\n#include <array>\r\n#include <format>\r\n#include <iostr"
},
{
"path": "examples/lesson09/fig09_23-27/Date.h",
"chars": 1732,
"preview": "// Fig. 9.23: Date.h \r\n// Date class definition; member functions defined in Date.cpp\r\n#pragma once // prevent multiple "
},
{
"path": "examples/lesson09/fig09_23-27/Employee.cpp",
"chars": 2216,
"preview": "// Fig. 9.26: Employee.cpp\r\n// Employee class member-function definitions.\r\n#include <format>\r\n#include <iostream>\r\n#inc"
},
{
"path": "examples/lesson09/fig09_23-27/Employee.h",
"chars": 1832,
"preview": "// Fig. 9.25: Employee.h\r\n// Employee class definition showing composition.\r\n// Member functions defined in Employee.cpp"
},
{
"path": "examples/lesson09/fig09_23-27/fig09_27.cpp",
"chars": 1510,
"preview": "// fig09_27.cpp\r\n// Demonstrating composition--an object with member objects.\r\n#include <format>\r\n#include <iostream>\r\n#"
},
{
"path": "examples/lesson09/fig09_28/fig09_28.cpp",
"chars": 1916,
"preview": "// fig09_28.cpp \r\n// Friends can access private members of a class.\r\n#include <format>\r\n#include <iostream>\r\n\r\n// Count"
},
{
"path": "examples/lesson09/fig09_29/fig09_29.cpp",
"chars": 2143,
"preview": "// fig09_29.cpp \r\n// Using the this pointer to refer to object members.\r\n#include <format>\r\n#include <iostream>\r\n\r\nclas"
},
{
"path": "examples/lesson09/fig09_30-32/Time.cpp",
"chars": 2980,
"preview": "// Fig. 9.31: Time.cpp \r\n// Time class member-function definitions.\r\n#include <format>\r\n#include <stdexcept>\r\n#include \""
},
{
"path": "examples/lesson09/fig09_30-32/Time.h",
"chars": 2075,
"preview": "// Fig. 9.30: Time.h\r\n// Time class modified to enable cascaded member-function calls.\r\n#pragma once // prevent multiple"
},
{
"path": "examples/lesson09/fig09_30-32/fig09_32.cpp",
"chars": 1709,
"preview": "// fig09_32.cpp\r\n// Cascading member-function calls with the this pointer.\r\n#include <format>\r\n#include <iostream>\r\n#inc"
},
{
"path": "examples/lesson09/fig09_33-35/Employee.cpp",
"chars": 2256,
"preview": "// Fig. 9.34: Employee.cpp\r\n// Employee class member-function definitions.\r\n#include <format>\r\n#include <iostream>\r\n#inc"
},
{
"path": "examples/lesson09/fig09_33-35/Employee.h",
"chars": 1833,
"preview": "// Fig. 9.33: Employee.h\r\n// Employee class definition with a static data member to \r\n// track the number of Employee ob"
},
{
"path": "examples/lesson09/fig09_33-35/fig09_35.cpp",
"chars": 2402,
"preview": "// fig09_35.cpp\r\n// static data member tracking the number of objects of a class.\r\n#include <format>\r\n#include <iostream"
},
{
"path": "examples/lesson09/fig09_36-37/cipher.h",
"chars": 7843,
"preview": "// Fig. 9.37: cipher.h\r\n// Vigenre cipher implementation. \r\n#pragma once\r\n#include <algorithm>\r\n#include <array>\r\n#inclu"
},
{
"path": "examples/lesson09/fig09_36-37/fig09_36.cpp",
"chars": 1781,
"preview": "// fig09_36.cpp\r\n// Encrypting and decrypting text with a Vigenre cipher. \r\n#include \"cipher.h\"\r\n#include <iostream>\r\n#i"
},
{
"path": "examples/lesson09/fig09_38/fig09_38.cpp",
"chars": 2933,
"preview": "// fig09_38.cpp\r\n// Serializing and deserializing objects with the cereal library.\r\n#include <cereal/archives/json.hpp> "
},
{
"path": "examples/lesson09/fig09_38/records.json",
"chars": 298,
"preview": "{\n \"records\": [\n {\n \"account\": 100,\n \"first\": \"Brian\",\n \"last\": \"Blue\",\n "
},
{
"path": "examples/lesson10/fig10_01-03/SalariedEmployee.cpp",
"chars": 2576,
"preview": "// Fig. 10.2: SalariedEmployee.cpp\r\n// Class SalariedEmployee member-function definitions.\r\n#include <format>\r\n#include "
},
{
"path": "examples/lesson10/fig10_01-03/SalariedEmployee.h",
"chars": 1627,
"preview": "// Fig. 10.1: SalariedEmployee.h\r\n// SalariedEmployee class definition.\r\n#pragma once // prevent multiple inclusions of "
},
{
"path": "examples/lesson10/fig10_01-03/fig10_03.cpp",
"chars": 1870,
"preview": "// fig10_03.cpp\r\n// SalariedEmployee class test program.\r\n#include <format>\r\n#include <iostream>\r\n#include \"SalariedEmpl"
},
{
"path": "examples/lesson10/fig10_04-06/SalariedCommissionEmployee.cpp",
"chars": 3015,
"preview": "// Fig. 10.5: SalariedCommissionEmployee.cpp\r\n// Class SalariedCommissionEmployee member-function definitions.\r\n#include"
},
{
"path": "examples/lesson10/fig10_04-06/SalariedCommissionEmployee.h",
"chars": 1797,
"preview": "// Fig. 10.4: SalariedCommissionEmployee.h\r\n// SalariedCommissionEmployee class derived from class SalariedEmployee.\r\n#p"
},
{
"path": "examples/lesson10/fig10_04-06/SalariedEmployee.cpp",
"chars": 2576,
"preview": "// Fig. 10.2: SalariedEmployee.cpp\r\n// Class SalariedEmployee member-function definitions.\r\n#include <format>\r\n#include "
},
{
"path": "examples/lesson10/fig10_04-06/SalariedEmployee.h",
"chars": 1627,
"preview": "// Fig. 10.1: SalariedEmployee.h\r\n// SalariedEmployee class definition.\r\n#pragma once // prevent multiple inclusions of "
},
{
"path": "examples/lesson10/fig10_04-06/fig10_06.cpp",
"chars": 2114,
"preview": "// fig10_06.cpp\r\n// SalariedCommissionEmployee class test program.\r\n#include <format>\r\n#include <iostream>\r\n#include \"Sa"
},
{
"path": "examples/lesson10/fig10_07/SalariedCommissionEmployee.cpp",
"chars": 3015,
"preview": "// Fig. 10.5: SalariedCommissionEmployee.cpp\r\n// Class SalariedCommissionEmployee member-function definitions.\r\n#include"
},
{
"path": "examples/lesson10/fig10_07/SalariedCommissionEmployee.h",
"chars": 1797,
"preview": "// Fig. 10.4: SalariedCommissionEmployee.h\r\n// SalariedCommissionEmployee class derived from class SalariedEmployee.\r\n#p"
},
{
"path": "examples/lesson10/fig10_07/SalariedEmployee.cpp",
"chars": 2576,
"preview": "// Fig. 10.2: SalariedEmployee.cpp\r\n// Class SalariedEmployee member-function definitions.\r\n#include <format>\r\n#include "
},
{
"path": "examples/lesson10/fig10_07/SalariedEmployee.h",
"chars": 1627,
"preview": "// Fig. 10.1: SalariedEmployee.h\r\n// SalariedEmployee class definition.\r\n#pragma once // prevent multiple inclusions of "
},
{
"path": "examples/lesson10/fig10_07/fig10_07.cpp",
"chars": 2863,
"preview": "// fig10_07.cpp\r\n// Aiming base-class and derived-class pointers at base-class\r\n// and derived-class objects, respective"
},
{
"path": "examples/lesson10/fig10_08/SalariedCommissionEmployee.cpp",
"chars": 3015,
"preview": "// Fig. 10.5: SalariedCommissionEmployee.cpp\r\n// Class SalariedCommissionEmployee member-function definitions.\r\n#include"
},
{
"path": "examples/lesson10/fig10_08/SalariedCommissionEmployee.h",
"chars": 1797,
"preview": "// Fig. 10.4: SalariedCommissionEmployee.h\r\n// SalariedCommissionEmployee class derived from class SalariedEmployee.\r\n#p"
},
{
"path": "examples/lesson10/fig10_08/SalariedEmployee.cpp",
"chars": 2576,
"preview": "// Fig. 10.2: SalariedEmployee.cpp\r\n// Class SalariedEmployee member-function definitions.\r\n#include <format>\r\n#include "
},
{
"path": "examples/lesson10/fig10_08/SalariedEmployee.h",
"chars": 1627,
"preview": "// Fig. 10.1: SalariedEmployee.h\r\n// SalariedEmployee class definition.\r\n#pragma once // prevent multiple inclusions of "
},
{
"path": "examples/lesson10/fig10_08/fig10_08.cpp",
"chars": 1510,
"preview": "// fig10_08.cpp\r\n// Aiming a derived-class pointer at a base-class object.\r\n#include \"SalariedEmployee.h\"\r\n#include \"Sal"
},
{
"path": "examples/lesson10/fig10_09/SalariedCommissionEmployee.cpp",
"chars": 3015,
"preview": "// Fig. 10.5: SalariedCommissionEmployee.cpp\r\n// Class SalariedCommissionEmployee member-function definitions.\r\n#include"
},
{
"path": "examples/lesson10/fig10_09/SalariedCommissionEmployee.h",
"chars": 1797,
"preview": "// Fig. 10.4: SalariedCommissionEmployee.h\r\n// SalariedCommissionEmployee class derived from class SalariedEmployee.\r\n#p"
},
{
"path": "examples/lesson10/fig10_09/SalariedEmployee.cpp",
"chars": 2576,
"preview": "// Fig. 10.2: SalariedEmployee.cpp\r\n// Class SalariedEmployee member-function definitions.\r\n#include <format>\r\n#include "
},
{
"path": "examples/lesson10/fig10_09/SalariedEmployee.h",
"chars": 1627,
"preview": "// Fig. 10.1: SalariedEmployee.h\r\n// SalariedEmployee class definition.\r\n#pragma once // prevent multiple inclusions of "
},
{
"path": "examples/lesson10/fig10_09/fig10_09.cpp",
"chars": 2047,
"preview": "// fig10_09.cpp\r\n// Attempting to call derived-class-only functions\r\n// via a base-class pointer.\r\n#include <string>\r\n#i"
},
{
"path": "examples/lesson10/fig10_10/SalariedCommissionEmployee.cpp",
"chars": 3015,
"preview": "// Fig. 10.5: SalariedCommissionEmployee.cpp\r\n// Class SalariedCommissionEmployee member-function definitions.\r\n#include"
},
{
"path": "examples/lesson10/fig10_10/SalariedCommissionEmployee.h",
"chars": 1815,
"preview": "// Fig. 10.4: SalariedCommissionEmployee.h\r\n// SalariedCommissionEmployee class derived from class SalariedEmployee.\r\n#p"
},
{
"path": "examples/lesson10/fig10_10/SalariedEmployee.cpp",
"chars": 2576,
"preview": "// Fig. 10.2: SalariedEmployee.cpp\r\n// Class SalariedEmployee member-function definitions.\r\n#include <format>\r\n#include "
},
{
"path": "examples/lesson10/fig10_10/SalariedEmployee.h",
"chars": 1643,
"preview": "// Fig. 10.1: SalariedEmployee.h\r\n// SalariedEmployee class definition.\r\n#pragma once // prevent multiple inclusions of "
},
{
"path": "examples/lesson10/fig10_10/fig10_10.cpp",
"chars": 3158,
"preview": "// fig10_10.cpp\r\n// Introducing polymorphism, virtual functions and dynamic binding.\r\n#include <format>\r\n#include <iostr"
},
{
"path": "examples/lesson10/fig10_11-17/CommissionEmployee.cpp",
"chars": 2944,
"preview": "// Fig. 10.16: CommissionEmployee.cpp\r\n// CommissionEmployee class member-function definitions.\r\n#include <format>\r\n#inc"
},
{
"path": "examples/lesson10/fig10_11-17/CommissionEmployee.h",
"chars": 1963,
"preview": "// Fig. 10.15: CommissionEmployee.h\r\n// CommissionEmployee class derived from Employee.\r\n#pragma once\r\n#include <string>"
},
{
"path": "examples/lesson10/fig10_11-17/Employee.cpp",
"chars": 1952,
"preview": "// Fig. 10.12: Employee.cpp\r\n// Abstract-base-class Employee member-function definitions.\r\n// Note: No definitions are g"
},
{
"path": "examples/lesson10/fig10_11-17/Employee.h",
"chars": 1688,
"preview": "// Fig. 10.11: Employee.h\r\n// Employee abstract base class.\r\n#pragma once // prevent multiple inclusions of header\r\n#inc"
},
{
"path": "examples/lesson10/fig10_11-17/SalariedEmployee.cpp",
"chars": 2061,
"preview": "// Fig. 10.14: SalariedEmployee.cpp\r\n// SalariedEmployee class member-function definitions.\r\n#include <format>\r\n#include"
},
{
"path": "examples/lesson10/fig10_11-17/SalariedEmployee.h",
"chars": 1804,
"preview": "// Fig. 10.13: SalariedEmployee.h\r\n// SalariedEmployee class derived from Employee.\r\n#pragma once\r\n#include <string> // "
},
{
"path": "examples/lesson10/fig10_11-17/fig10_17.cpp",
"chars": 3439,
"preview": "// fig10_17.cpp\r\n// Processing Employee derived-class objects with variable-name handles \r\n// then polymorphically using"
},
{
"path": "examples/lesson10/fig10_19-26/Commission.cpp",
"chars": 2222,
"preview": "// Fig. 10.25: Commission.cpp\r\n// Commission member-function definitions.\r\n#include <format>\r\n#include <stdexcept>\r\n#inc"
},
{
"path": "examples/lesson10/fig10_19-26/Commission.h",
"chars": 1550,
"preview": "// Fig. 10.24: Commission.h\r\n// Commission implements the CompensationModel interface.\r\n#pragma once\r\n#include <string> "
},
{
"path": "examples/lesson10/fig10_19-26/CompensationModel.h",
"chars": 1505,
"preview": "// Fig. 10.19: CompensationModel.h\r\n// CompensationModel \"interface\" is a pure abstract base class.\r\n#pragma once // pre"
},
{
"path": "examples/lesson10/fig10_19-26/Employee.cpp",
"chars": 2109,
"preview": "// Fig. 10.21: Employee.cpp\r\n// Class Employee member-function definitions.\r\n#include <format> \r\n#include <string> \r\n#in"
},
{
"path": "examples/lesson10/fig10_19-26/Employee.h",
"chars": 1625,
"preview": "// Fig. 10.20: Employee.h\r\n// An Employee \"has a\" CompensationModel.\r\n#pragma once // prevent multiple inclusions of hea"
},
{
"path": "examples/lesson10/fig10_19-26/Salaried.cpp",
"chars": 1724,
"preview": "// Fig. 10.23: Salaried.cpp\r\n// Salaried compensation model member-function definitions.\r\n#include <format>\r\n#include <s"
},
{
"path": "examples/lesson10/fig10_19-26/Salaried.h",
"chars": 1488,
"preview": "// Fig. 10.22: Salaried.h\r\n// Salaried implements the CompensationModel interface.\r\n#pragma once\r\n#include <string> \r\n#i"
},
{
"path": "examples/lesson10/fig10_19-26/fig10_26.cpp",
"chars": 1894,
"preview": "// fig10_26.cpp\r\n// Processing Employees with various CompensationModels.\r\n#include <format>\r\n#include <iostream>\r\n#incl"
},
{
"path": "examples/lesson11/fig11_01/fig11_01.cpp",
"chars": 4425,
"preview": "// fig11_01.cpp\r\n// Standard library string class test program.\r\n#include <iostream>\r\n#include <string> \r\n#include <stri"
},
{
"path": "examples/lesson11/fig11_02/fig11_02.cpp",
"chars": 1929,
"preview": "// fig11_02.cpp\r\n// Demonstrating unique_ptr.\r\n#include <iostream>\r\n#include <memory>\r\nusing namespace std;\r\n\r\nclass Int"
},
{
"path": "examples/lesson11/fig11_03-05/MyArray.cpp",
"chars": 6897,
"preview": "// Fig. 11.5: MyArray.cpp\r\n// MyArray class member- and friend-function definitions.\r\n#include <algorithm>\r\n#include <in"
},
{
"path": "examples/lesson11/fig11_03-05/MyArray.h",
"chars": 3273,
"preview": "// Fig. 11.4: MyArray.h\r\n// MyArray class definition with overloaded operators.\r\n#pragma once\r\n#include <initializer_lis"
},
{
"path": "examples/lesson11/fig11_03-05/fig11_03.cpp",
"chars": 5191,
"preview": "// fig11_03.cpp\r\n// MyArray class test program.\r\n#include <iostream>\r\n#include <stdexcept>\r\n#include <utility> // for st"
},
{
"path": "examples/lesson11/fig11_06/fig11_06.cpp",
"chars": 2910,
"preview": "// fig11_06.cpp\r\n// C++20 three-way comparison (spaceship) operator.\r\n#include <compare>\r\n#include <iostream>\r\n#include "
}
]
// ... and 1754 more files (download for full content)
About this extraction
This page contains the full source code of the pdeitel/CPlusPlus20FundamentalsLiveLessons GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1954 files (18.9 MB), approximately 5.1M tokens, and a symbol index with 11721 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.