CPP / C++ Notes - C++ Libraries Review

template <class T, class = std::enable_if_t<std::is_pointer<T>::value>>
using owner = T;

IBaseClass*  factoryFunction(int key)
{
   if(key == VALUE1)
   { 
     return new Implementation1(arg1, arg2, ...);
   }
   if(key == VALUE1)
   { 
     return new Implementation2;
   }
   //  ... ... ... . 
   // Invalid input 
  return nullptr; 
} 

#include <gls/pointer>

gsl::owner<IBaseClass*>  
factoryFunction(int key)
{
   if(key == VALUE1)
   { 
     return new Implementation1(arg1, arg2, ...);
   }
   if(key == VALUE1)
   { 
     return new Implementation2;
   }
   //  ... ... ... . 
   // Invalid input 
  return nullptr; 
} 

//  --------- Usage: ------------------// 

int main()
{ 
    std::cout << " Choose the implementation: ";
    int key; 
    std::cin >> key; 

   gsl::owner<IBaseClass*> object = factoryFunction(key); 

   object->InvokeVirtualMemberFunction();
   // ... ... ... ..

  delete object;
 }

{
   int* arr = new int [10]; 

   // RAII => Calls lambda when this object is out-of-scope 
   // and its destructor is called. 
   auto scope_guard = gsl::finally( [=]
                   { 
                      delete [] arr;
                      std::puts("Resource cleaned OK.");
                   });

   for(size_t i = 0; i < 10; i++) { /** set arrary */ }   
} // scope_guard called here. 

#include <gls/gls> // Include all heders

double xx = 105e4;

// Same as static_cast, but the intent is more clear.  Makes easier to
// the reader spot that a loss of information or precision may happen.
// 
// Note: If an underflow/overflow happens in this case, it is
// undefined behavihor. UB
int nx = gsl::narrow_cast<int>(xx);

#include <gls/gls> // Include all heders

double xx = 10.535e10;
nx = gsl::narrow<int>(xx);

// --------- Constructors for dynamic-size span  -----------// 
gls::span(); 
gsL::span(nullptr_t) noexcept; 
gls::span(pointer ptr, index_type number_of_elements);
gls::span(pointer ptrFirstElement, ptrLastElement);

template <class Container> gls::span(Container& container);

// --------- Constructors for fixed-size span ---------------//

// Array buffer of size N. i.e:  int array [10] = { 1, 2, ..., 10};
template <size_t N> gsl::span(element_type (&array) [N]);

template <size_t N> gsl::span(Container& container);
template <size_t N> gsl::span(Container const& container);

gsl::span<int> sp;

//--------- assign C-array to span -------------- // 
int carr [] = {-15, 6, 10, 9, 200};
sp = xs;                 // sp refers to array xs 
assert(sp[2] == 10); 
assert(sp[3] == 9);
assert(sp.size() == 5);
assert()

//------ Assign fixed-size buffer (C-array) to span ---// 
int buffer[200] = {3, 5, 6, 10, 20};
sp = buffer;
assert(sp.size() == 200);
assert(sp[2] == 6);
assert(sp[0] == 3);

//---- Assign to buffer defined by (pointer, size) tuple to span ---// 
int* p_buffer = &carr; 
auto buffer_size = gsl::index(5);
sp = gsl::make_span(p_buffer, buffer_size); 
assert(sp.size() == 5);
assert(sp[0] == -15);
assert(sp[2] ==  10);

//------ assign std::vector cointainer to span -------// 
std::vector<int> xs = {1, 2, 3, 4, 5};
sp = xs;                 // sp refers to vector xs 
assert(sp[2] == 3);
assrrt(sp.size() == 5);  

//------ assign std::array to span -------------------//
std::array<int, 6> arr = {10, 20, 30, 40, 50, 60}; 
sp = arr;  // sp refers to std::array arr 
assert(sp[2] == 30);
assert(sp.size() == 6)

int dataset [] = {200, 100, -90, 89, 610, 53, 1365};
std::span<int> arrview;  
arrview = dataset; 

for(auto idx = gsl::index(0); idx < arr.size(); ++idx)
{
   std::cout << " Element[" << idx << "] =" << arrview[idx] << "\n";
}

for(auto it = arrview.begin(); it != arrview.end(); ++it)
{
   std::cout << *it << std::endl;
}

for(auto it = std::begin(arrview); it != std::end(arrview); ++it)
{
   std::cout << *it << std::endl;
}

for(auto const& x:  arrview)
{
   std::cout << x << "\n";
}

 std::for_each(arrview.begin(), arrview.end(), [](int n)
              {
                  std::cout << n << "\n";
              });

std::sort(arrview.begin(), arrview.end());

int sum_span_element(gsl::span<int> xs)
{
    int sum = 0;
    for(auto x: xs){ sum += x; }
    return sum;
}

gsl::span<int> sp; 

// ------ Passing a C-array argument ------------------------------//
int carr [] = {-15, 6, 10, 9, 200};
sp = carr;
assert(sum_span_element(carr) == 210);
assert(sum_span_element(sp) == 210);

// ----- Passing a buffer argument defined by (pointer, size) pair ---// 
int* buffer_ptr  = carr; // Address of carr[0]
int  buffer_size = 5; 
sp = gsl::make_span(buffer_ptr, buffer_size);
assert( sum_span_element(sp) == 210 );
assert( sum_span_element(gsl::make_span(buffer_ptr, gsl::index(buffer_size))) == 210 );
assert( sum_span_element({buffer_ptr, gsl::index(buffer_size)}) == 210 );

// ---- Passing a std::vector argument ------------------//
std::vector<int> vec =  {10, 256, -15, 20, -8}; 
sp = vec; 
assert( sum_span_element(sp) == 263 );
assert( sum_span_element(vec) == 263 );

cmake_minimum_required(VERSION 3.14)
project(gls_experiment)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)

# See documentation at: https://cmake.org/cmake/help/latest/module/FetchContent.html

#========== Macros for automating Library Fetching =============#
include(FetchContent)

# Download library archive (zip, *.tar.gz, ...) from URL
macro(Download_Library_Url NAME URL)
    FetchContent_Declare(${NAME} URL  ${URL})
    FetchContent_GetProperties(${NAME})
    message( [DOWNLOAD LIB] " VAR1 = ${${NAME}_SOURCE_DIR}")
    if(NOT ${NAME}_POPULATED)
        FetchContent_Populate(${NAME})
        add_subdirectory(${${NAME}_SOURCE_DIR} ${${NAME}_BINARY_DIR})
    endif()
endmacro()

#============== Library Download =========================#

Download_Library_Url( gsl
                      https://github.com/microsoft/GSL/archive/v2.0.0.zip
                     )

# ========= Targets Settings ==========================#

add_executable(microsft_gsl  microsft_gsl.cpp)
target_link_libraries(microsft_gsl GSL)

#include <iostream>
#include <iomanip>
#include <memory>
#include <vector>
#include <array>
#include <algorithm>
#include <numeric>

// #define GSL_UNENFORCED_ON_CONTRACT_VIOLATION
// #define GSL_TERMINATE_ON_CONTRACT_VIOLATION
#define GSL_THROW_ON_CONTRACT_VIOLATION

// ------ Headers from the GSL - Guideline Support Library ----------//
//-------------------------------------------------------------------//
//#include <gsl/gsl> // For including everything
#include <gsl/gsl>
#include <gsl/span>
#include <gsl/pointers>

void display_span(const char* name, gsl::span<int> xs)
{
    std::cout << "  => " << name << " = [ ";
    for(auto const& x: xs){ std::cout << x << ", "; }
    std::cout <<  " ]\n";
}

template<typename T>
void disp(const char* label, T&& value)
{
    std::cout << std::setw(5)  << "  =>> "
              << std::setw(10) << label
              << std::setw(4) << "="
              << std::setw(6) << value
              << std::endl;
}

int cstring_len(gsl::not_null<const char*> ptr)
{
    int n = 0;
    for(auto p = ptr.get(); *p != '\0'; ++p) n++;
    return n;
}

int main()
{


    std::puts("\n ==== EXPERIMENT 1 - gsl::span variable =====================\n");
    {
        // Variable span, non owning view that can refere to any contiguous memory,
        // C-array buffers; buffers (pointer, size) tuple; std::vector; std::array
        gsl::span<int> sp;

        int carray [] = {10, 5, 8, 5, 6, 15};
        sp = carray;

        int* ptr_data = sp.data();

        display_span("carray [A]", sp);
        display_span("carray [B]", carray);
        disp(" *(carray.data + 0) ", *ptr_data);
        disp(" *(carray.data + 0) ", *(ptr_data + 1));


        // Display buffer defined by tuple (pointer, size)
        int*   buffer_ptr  = carray;
        size_t buffer_size = std::size(carray);
        sp = gsl::make_span(buffer_ptr, buffer_size);
        display_span("buffer", sp);

        std::vector<int> vector1 = {10, 256, -15, 20, -8};
        sp = vector1; // View refers to vector1
        display_span("vector1 [A]", sp);
        display_span("vector1 [B]", sp);

        // Just a nice C++ wrapper for a C stack-allocated or static-allocated array
        // It encapsulates the array: int [] std_array = {100, ...}
        std::array<int, 7> std_array = {100, -56, 6, 87, 61, 25, 151};
        sp = std_array;
        display_span("std_array [A]", sp);
        display_span("std_array [B]", sp);
    }

    std::puts("\n ==== EXPERIMENT 2 - gsl::span with std algorithms  ======\n");
    {
        int carray [] = {8, 10, 5, 90, 0, 14};
        gsl::span<int> sp;
        sp = carray;

        display_span("carray <before>", sp);
        std::sort(sp.begin(), sp.end());
        display_span("carray <after>", sp);

        auto sum = std::accumulate(sp.begin(), sp.end(), 0);
        std::cout << " [INFO] sum of all elements  = " << sum << std::endl;
    }

    std::puts("\n ==== EXPERIMENT 3 - gsl::span methods ==================\n");

     {
         int carrayA [] = {10, 15, -8, 251, 56, 15, 100};
         auto sp = gsl::span{carrayA};        

         std::cout << std::boolalpha;

         // Returns true if the view points to an empty location
         disp("sp.empty()", sp.empty());
         // Returns the number of elements
         disp("sp.size()", sp.size());
         // Returns the total size in bytes
         disp("sp.size_byte()", sp.size_bytes());                  

         // --- Access to elements with array-index operator [] -------//
         // Note: The bound checking only happens in the debug build.
         //       In the release build, it is disabled.
         disp("sp[0]", sp[0]);
         disp("sp[4]", sp[4]);
         disp("sp[5]", sp[5]);

         sp[0] = 100;

         // ---- Access to elements with always enabled, throws exception
         // if the access is out of bounds.
         disp("sp.at(0)", sp.at(0));
         disp("sp.at(4)", sp.at(5));
         disp("sp.at(5)", sp.at(4));

         // Note 1: The bound checking with array operator is only enabled
         // for debug building, in the release building it can be disabled
         // due to performance reasons.
         //
         // Note 2: It only throws exception, if the macro
         // GSL_THROW_ON_CONTRACT_VIOLATION is defined before GSL includes.
         // Otherwise, it calls std::terminate without throwing an exception.
         try
         {
             disp("sp[15]", sp[15]);
         } catch (gsl::fail_fast& ex)
         {
             std::cout << "  [ERROR] Failure = " << ex.what() << std::endl;
         }
     }


    return 0;
}

==== EXPERIMENT 1 - gsl::span variable =====================

 => carray [A] = [ 10, 5, 8, 5, 6, 15,  ]
 => carray [B] = [ 10, 5, 8, 5, 6, 15,  ]
 =>>  *(carray.data + 0)    =    10
 =>>  *(carray.data + 0)    =     5
 => buffer = [ 10, 5, 8, 5, 6, 15,  ]
 => vector1 [A] = [ 10, 256, -15, 20, -8,  ]
 => vector1 [B] = [ 10, 256, -15, 20, -8,  ]
 => std_array [A] = [ 100, -56, 6, 87, 61, 25, 151,  ]
 => std_array [B] = [ 100, -56, 6, 87, 61, 25, 151,  ]

==== EXPERIMENT 2 - gsl::span with std algorithms  ======

 => carray <before> = [ 8, 10, 5, 90, 0, 14,  ]
 => carray <after> = [ 0, 5, 8, 10, 14, 90,  ]
[INFO] sum of all elements  = 127

==== EXPERIMENT 3 - gsl::span methods ==================

 =>> sp.empty()   = false
 =>>  sp.size()   =     7
 =>> sp.size_byte()   =    28
 =>>      sp[0]   =    10
 =>>      sp[4]   =    56
 =>>      sp[5]   =    15
 =>>   sp.at(0)   =   100
 =>>   sp.at(4)   =    15
 =>>   sp.at(5)   =    56
 [ERROR] Failure = GSL: Precondition failure at ... .../_deps/gsl-src/include/gsl/span: 499

$ git clone https://github.com/fmtlib/fmt

# Build directory /home/<USER>/dev on Linux 
$ mkdir -p ~/dev && cd dev                           
# Clone repository 
$ git clone https://github.com/fmtlib/fmt
# Extract headers 
$ cp -r -v fmt/include ~/dev/
# Delete fmt directory 
$ rm -rf fmt 

#include <iostream>
#include <fstream>
#include <cmath>
#include <sstream>

// If defined before including fmt, uses it as header-only library
#define FMT_HEADER_ONLY

// Basic functionality
#include <fmt/core.h>
// fmt string literals "name"_a, "product"_a
#include <fmt/format.h>
// Print to streams std::cout, std::cerr, std::ostream
#include <fmt/ostream.h>

#include <fmt/color.h>

// #include <fmt/color.h>

using namespace fmt::literals;

void printHeader(const char* header)
{
    fmt::print("\n{}\n", header);
    fmt::print("---------------------------------------------\n");
}

int main()
{
    printHeader(" ***** EXPERIMENT 1 - Boolean  *************");
    fmt::print(" true == {0} ; false == {1} \n", true, false);


    printHeader(" ***** EXPERIMENT 2 - Numeric Base  *********");

    fmt::print(" [BASES] => dec: {0:d} ; hex = 0x{0:X} "
               " ; oct = {0:o} ; bin = 0b{0:b} \n", 241 );

    printHeader(" ***** EXPERIMENT 3 - Positional arguments ****");

    fmt::print(" first = {0}, 2nd = {1}, 1st = {1}, 3rd = {2}\n",
                200, "hello", 5.615);

    printHeader("**** EXPERIMENT 4 - Named Arguments ********* ");

    fmt::print(" [A] Product => product = {0} id = {1} price = {2}\n"
               ,"oranges 1 kg", 200, 10.6758 );

    // Requires: #include <fmt/format.h>
    // using namespace fmt::literals;
    fmt::print(" [B] Product => product = {product} id = {id} price = {price:.2F}\n"
               , "product"_a = "oranges 1 kg", "id"_a = 200, "price"_a = 10.6758 );

    fmt::print(" [B] Product => product = {product} id = {id} price = {price:.2F}\n"
               , fmt::arg("product", "oranges 1 kg")
               , fmt::arg("id",  200)
               , fmt::arg("price", 10.6758 ));

    printHeader("************ Colored Output ******************");

    fmt::print( fmt::fg(fmt::color::aqua) | fmt::emphasis::bold,
               " [INFO] Voltage Leval  = {0:+.3F}\n", 10.6478);

    fmt::print( fmt::fg(fmt::color::red) | fmt::emphasis::underline,
               " [ERROR] Fatal Error, shutdown systems code  0x{0:X}\n", 2651);


    printHeader(" ***** EXPERIMENT 5 - Numeric Formatting ******");

    double x = 20.0;
    fmt::print("The square root of x = {}\n", std::sqrt(x));

    x = 28524.0;

    fmt::print(" log(x) = {:.2F}  (2 digit precision)\n", std::log(x));
    fmt::print(" log(x) = {:+.6F} (6 digit precision)\n", std::log(x));
    fmt::print(" 2000 * log(x) = {:+.6G} (6 digit precision)\n", 1e5 * std::log(x));
    fmt::print("  log(x) = {0:+.8E} ; sqrt(x) = {1:+8E} (8 digit precision)\n",
               std::log(x), std::sqrt(x));

    printHeader(" ***** EXPERIMENT 6 - Print numeric table ******");

    int i = 0;
    for(double x = 0.0; x <= 4.0; x += 0.5)
        fmt::print("{0:8d}{1:10.5F}{2:10.5F}\n", i++, x, std::exp(x));

    printHeader(" ***** EXPERIMENT 7 - Print table to file *******");

    // std::ofstream file("/tmp/table.txt");
    std::stringstream file; // Fake file

    i = 0;

    // Note: Requires <fmt/ostream.h>
    for(double x = -4.0; x <= 4.0; x += 1.0)
        fmt::print(file, "{0:8d}{1:10.5F}{2:10.5F}\n", i++, x, std::exp(x));

    fmt::print("File content = \n{0}", file.str());

    return 0;
}

 ***** EXPERIMENT 1 - Boolean  *************
---------------------------------------------
 true == true ; false == false 

 ***** EXPERIMENT 2 - Numeric Base  *********
---------------------------------------------
 [BASES] => dec: 241 ; hex = 0xF1  ; oct = 361 ; bin = 0b11110001 

 ***** EXPERIMENT 3 - Positional arguments ****
---------------------------------------------
 first = 200, 2nd = hello, 1st = hello, 3rd = 5.615

**** EXPERIMENT 4 - Named Arguments ********* 
---------------------------------------------
 [A] Product => product = oranges 1 kg id = 200 price = 10.6758
 [B] Product => product = oranges 1 kg id = 200 price = 10.68
 [B] Product => product = oranges 1 kg id = 200 price = 10.68

************ Colored Output ******************
---------------------------------------------
 [INFO] Voltage Leval  = +10.648
 [ERROR] Fatal Error, shutdown systems code  0xA5B

 ***** EXPERIMENT 5 - Numeric Formatting ******
---------------------------------------------
The square root of x = 4.47213595499958
 log(x) = 10.26  (2 digit precision)
 log(x) = +10.258501 (6 digit precision)
 2000 * log(x) = +1.02585e+06 (6 digit precision)
  log(x) = +1.02585011E+01 ; sqrt(x) = +1.688905E+02 (8 digit precision)

 ***** EXPERIMENT 6 - Print numeric table ******
---------------------------------------------
       0   0.00000   1.00000
       1   0.50000   1.64872
       2   1.00000   2.71828
       3   1.50000   4.48169
       4   2.00000   7.38906
       5   2.50000  12.18249
       6   3.00000  20.08554
       7   3.50000  33.11545
       8   4.00000  54.59815

 ***** EXPERIMENT 7 - Print table to file *******
---------------------------------------------
File content = 
       0  -4.00000   0.01832
       1  -3.00000   0.04979
       2  -2.00000   0.13534
       3  -1.00000   0.36788
       4   0.00000   1.00000
       5   1.00000   2.71828
       6   2.00000   7.38906
       7   3.00000  20.08554
       8   4.00000  54.59815

$ g++  fmttest.cpp -o app.bin -std=c++1z -Wall -I$HOME/dev/include 

# Or, on Linux
$ clang++  fmttest.cpp -o app.bin -std=c++1z -Wall -I/home/<USER>/dev/include 

# Or, On OSX 
$ clang++  fmttest.cpp -o app.bin -std=c++1z -Wall -I/Users/<USER>/dev/include 

#------------ Local Libraries Installation ---------------------
LOCAL_LIB_PATH=~/dev
export CPLUS_INCLUDE_PATH=$LOCAL_LIB_PATH/include:$CPLUS_INCLUDE_PATH
export C_INCLUDE_PATH=$LOCAL_LIB_PATH/include:$C_INCLUDE_PATH
export LIBRARY_PATH=$LOCAL_LIB_PATH/lib:$LIBRARY_PATH
export LD_LIBRARY_PATH=$LOCAL_LIB_PATH/lib:$LD_LIBRARY_PATH

$ g++  fmttest.cpp -o app.bin -std=c++1z -Wall

# Header only compilation takes 2 seconds 
$ time g++  fmttest.cpp -o app.bin -std=c++1z -Wall

real    0m1.824s
user    0m1.650s
sys     0m0.156s

#define FMT_HEADER_ONLY
#include <fmt/format.h>
#include <fmt/color.h>
#include <fmt/ostream.h>

>> fmt::print(" x = {0:.5F}, sqrt(x) = {1:+.8F}\n", 20.6, std::sqrt(20.6))
 x = 20.60000, sqrt(x) = +4.53872229
>> 

// Print with color foreground blue 
>> fmt::print(fmt::fg(fmt::color::blue), " [INFO] x = {0:.5E}\n", 20.6)
 [INFO] x = 2.06000E+01

// Print with background color blue 
>> fmt::print(fmt::bg(fmt::color::blue), " [INFO] x = {0:.5E}\n", 20.6)
 [INFO] x = 2.06000E+01
>> 

cmake_minimum_required(VERSION 2.8)
project(tinyprintf-test)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)

#============= Functions and macros ===========================#
macro(Download_Single_Headerlib FILE URL)
    file(DOWNLOAD ${URL} ${CMAKE_BINARY_DIR}/include/${FILE})
    IF(NOT Download_Single_Headerlib_flag)
       include_directories(${CMAKE_BINARY_DIR}/include)
       set(Download_Single_Headerlib_flag TRUE)
    ENDIF()
endmacro()

Download_Single_Headerlib(
    tinyformat.h
    "https://raw.githubusercontent.com/c42f/tinyformat/master/tinyformat.h"
    )

#============ Target settings ==================================#
add_executable(main main.cpp)

#include <iostream>
#include <string>
#include <cmath>
#include <vector>

#include <tinyformat.h>

template<typename T>
void display(T&& x)
{
    tfm::printfln(" Function = %s ; Value x = %s", __FUNCTION__, x);
}

struct Point3D
{
    double x, y, z;
};

/** Enables printing user defined data with tinyprintf library */
std::ostream&
operator<<(std::ostream& os, Point3D const& point )
{
    auto [x, y, z] = point;
    return os << " Point3d{ x = " << x
              << " ; y = " << y << " ; z = "
              << z << " } ";
}

int main(int argc, char** argv)
{
    std::string s = "Hello world";
    tfm::printf(" LINE 1 => s = %s n1 = %d f = %.3f \n", s, 10, 283.41345);

    tfm::printfln(" LINE 2 => arg1 = %1$s ; arg3 = %3$s ; arg2 = %2$d ", "A1", 1003, "A3");

    // Templated function
    display(10);
    display("Hello world C++20 ... modules");

    // Print user-defined type
    tfm::printfln("\n User Defined Data =>> = %s", Point3D{3.5, 100.34, -90.341});

    //==== Print to stream ===========//
    std::stringstream ss;
    for(int i = 0; i < 5; i++)
    {
        tfm::format(ss, "%8.d %10.5f\n", i, std::exp(i));
    }

    tfm::printfln("\nFunction tabulation result => \n %s", ss.str());

    return 0;
}

 % ./main 

 LINE 1 => s = Hello world n1 = 10 f = 283.413 
 LINE 2 => arg1 = A1 ; arg3 = A3 ; arg2 = 1003 
 Function = display ; Value x = 10
 Function = display ; Value x = Hello world C++20 ... modules

 User Defined Data =>> =  Point3d{ x = 3.5 ; y = 100.34 ; z = -90.341 } 

Function tabulation result => 
        0    1.00000
       1    2.71828
       2    7.38906
       3   20.08554
       4   54.59815

$ curl -O -L https://raw.githubusercontent.com/louisdx/cxx-prettyprint/master/prettyprint.hpp

$ ~/opt/root/bin/root.exe
   ------------------------------------------------------------
  | Welcome to ROOT 6.14/04                http://root.cern.ch |
  |                               (c) 1995-2018, The ROOT Team |
  | Built for linuxx8664gcc                                    |
  | From tags/v6-14-04@v6-14-04, Aug 23 2018, 17:00:44         |
  | Try '.help', '.demo', '.license', '.credits', '.quit'/'.q' |
   ------------------------------------------------------------

>> #include "prettyprint.hpp""

>> auto xs = std::vector<double>{434.4, -10.54, 9.654, 45.23, -10.56};

//------- Print Vector -----------------//
>>
>> std::cout << " xs = " << xs << std::endl;
 xs = [5](434.4 -10.54 9.654 45.23 -10.56 )
>>

>> auto t = std::make_tuple(std::string("hello"), 100)
(std::tuple<basic_string<char>, int> &) { "hello", 100 }

>> std::cout << " t = " << t << std::endl;
 t = (hello, 100)

>> auto tt = std::make_tuple(std::string("hello"), 100, 'x')
(std::tuple<basic_string<char>, int, char> &) { "hello", 100, 'x' }
>>
>> std::cout << " tt = " << tt << std::endl;
 tt = (hello, 100, x)

>> std::map<std::string, double> dataset {{"USD", 200.3}, {"BRL", 451.34}, {"CAD", 400.5}, {"AUD", 34.65}};

>> std::cout << " dataset = " << dataset << std::endl;
 dataset = [(AUD, 34.65), (BRL, 451.34), (CAD, 400.5), (USD, 200.3)]
>>

$ cd <PROJECT> 
$ curl -O -L https://raw.githubusercontent.com/p-ranav/pprint/v0.9.1/include/pprint.hpp

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <complex>

// Library from: https://github.com/p-ranav/pprint/tree/v0.9.1
#include <include/pprint.hpp>

using cpl = std::complex<double>;

int main()
{
    auto printer = pprint::PrettyPrinter{};

    std::puts("\n========= Print Numbers ============");
    printer.print(100);
    printer.print(59.15);

    std::puts("\n======= Print string with/without quotes =====");
    printer.print(" Testing CEE PLUS PLUS Printer");

    printer.quotes(false);
    printer.print(" Testing CEE PLUS PLUS Printer");
    printer.quotes(true);

    std::puts("\n=========== Print booleans ===========");
    printer.print(true);
    printer.print(false);

    std::puts("\n========== Print Null Pointer =========");
    printer.print(nullptr);

    std::puts("\n======== Print complex numbers =========");
    cpl x1{10.0, 15};
    auto x2 = cpl{-36.34, 98.765};
    cpl x3 = {-2.5312, -9.81};
    printer.quotes(false);
    printer.print("x1 = ", x1, " ; x2 = ", x2, " ; x3 = ", x3);

    std::puts("\n======= STL Container =================");

    std::puts(" --->> Print a vector <<----- ");

    std::vector<std::string> words = { "c++", "Ada", "Scala", "C++17", "Serial" };
    printer.print(words);

    std::puts(" --->> Print a map <<--------");
    std::map<std::string, double> dataset = { {"x", -9.4351}, {"mx", -100.35}, {"g", 9.814}  };
    printer.print(dataset);


    std::puts(" --->> Print a map / Compact <<--------");
    printer.compact(true);
    printer.print(dataset);


    std::puts(" -->> Print a vector of tuples <<------");
    printer.compact(false);
    auto xlist = std::vector<std::tuple<std::string, int>>{
        {"CAD", 100}, {"AUD", 900 }, {"BRL", 871}, {"EUR", 9871}
    };

    printer.print(xlist);

    std::puts("\n=== Print C++17 Variants =================");
    using var = std::variant<int, std::string, std::vector<int>>;
    std::vector<var> varlist = { 100, "hello", 51, std::vector{23, 100, -9, 8, 100}, "world" };
    printer.print(varlist);

    return 0;
}

./main.bin 

========= Print Numbers ============
100
59.15

======= Print string with/without quotes =====
" Testing CEE PLUS PLUS Printer"
 Testing CEE PLUS PLUS Printer

=========== Print booleans ===========
true
false

========== Print Null Pointer =========
nullptr

======== Print complex numbers =========
x1 =  (10 + 15i)  ; x2 =  (-36.34 + 98.765i)  ; x3 =  (-2.5312 + -9.81i)

======= STL Container =================
 --->> Print a vector <<----- 
[
  c++, 
  Ada, 
  Scala, 
  C++17, 
  Serial

]
 --->> Print a map <<--------
{
  g : 9.814, 
  mx : -100.35, 
  x : -9.4351
}
 --->> Print a map / Compact <<--------
{g : 9.814,   mx : -100.35, x : -9.4351}
 -->> Print a vector of tuples <<------
[
  ("CAD", 100), 
  ("AUD", 900), 
  ("BRL", 871), 
  ("EUR", 9871)
]

=== Print C++17 Variants =================
[
  100, 
  hello, 
  51, 
  [23, 100, -9, 8, 100], 
  world
]

cmake_minimum_required(VERSION 2.8)
project(cli11-app)

#========================================#

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)

#=========== Conan Bootstrap =================#

# Download automatically, you can also just copy the conan.cmake file
if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
   message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
   file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.13/conan.cmake"
                 "${CMAKE_BINARY_DIR}/conan.cmake")
endif()

include(${CMAKE_BINARY_DIR}/conan.cmake)
set(CONAN_PROFILE default)

conan_cmake_run( REQUIRES
                 CLI11/1.8.0@cliutils/stable
                 BASIC_SETUP
                 BUILD missing )

#=========== Find Package ================#

find_package(CLI11 REQUIRED)

#=========== Targets ======================#

# Note: CLI11 is a header-only library and does not need Linking
add_executable(httpserver main.cpp)

#include <iostream>
#include <fstream>
#include <string>

#include <CLI/CLI.hpp>

int main(int argc, char** argv)
{
    CLI::App app{ "C++ http Web Server"};
    app.footer("\n Creator: Somebody else.");

    // Sets the current path that will be served by the http server
    std::string dir = "default";
    app.add_option("directory", dir, "Directory served")->required();

    // Sets the port that the server will listen to
    int port = 8080;
    app.add_option("-p,--port", port, "TCP port which the server will bind/listen to");

    // Set the the hostname that the server will listen to
    // Default: 0.0.0.0 => Listen all hosts
    std::string host = "0.0.0.0";
    app.add_option("--host", host, "Host name that the sever will listen to.");

     app.validate_positionals();
    CLI11_PARSE(app, argc, argv);

    std::cout << "Running server at port = " << port
              << "\n and listen to host = " << host
              << "\n serving directory = " << dir << "\n";

    return 0;
}

$ ./httpserver -h
C++ http Web Server
Usage: ./httpserver [OPTIONS] directory

Positionals:
  directory TEXT REQUIRED     Directory served

Options:
  -h,--help                   Print this help message and exit
  -p,--port INT               TCP port which the server will bind/listen to
  --host TEXT                 Host name that the sever will listen to.

 Creator: Somebody else.

$ ./httpserver 
directory is required
Run with --help for more information.

$ ./httpserver /var/data/www
Running server at port = 8080
 and listen to host = 0.0.0.0
 servind directory = /var/data/www


$ ./httpserver /var/data/www --port=9090
Running server at port = 9090
 and listen to host = 0.0.0.0
 serving directory = /var/data/www


$ ./httpserver --port=9090 --host=localhost /home/user/pages
Running server at port = 9090
 and listen to host = localhost
 serving directory = /home/user/pages

cmake_minimum_required(VERSION 3.0)
project(clipp-test)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)

#============= Functions and macros ===========================#

macro(Download_Single_Headerlib FILE URL)
    file(DOWNLOAD ${URL} ${CMAKE_BINARY_DIR}/include/${FILE})
    IF(NOT Download_Single_Headerlib_flag)
       include_directories(${CMAKE_BINARY_DIR}/include)
       set(Download_Single_Headerlib_flag TRUE)
    ENDIF()
endmacro()

Download_Single_Headerlib(
    clipp.h
    https://raw.githubusercontent.com/muellan/clipp/v1.2.3/include/clipp.h
    )

#============ Targets settings ==================================#

add_executable( application application.cpp )

#include <iostream> 
#include <string> 

#include <clipp.h>

struct ServerOptions
{        
        // --------- Required values -------------------//
        int         port;
        std::string host; 

        // -------- Optional values -------------------//
        int         loglevel                = 1; 
        std::string name                    = "untitled";
        bool        require_authentication  = false;    
        bool        verbose                 = false;         
};

int main(int argc, char* argv []) 
{
        ServerOptions opts; 

        auto cli = (
                // --- Positional values ===>> Required --------------//
                  clipp::value("host name", opts.host)
                , clipp::value("server port", opts.port)

                // --- Optional values ------------------------//
                , clipp::option("-v", "--verbose")
                        .set(opts.verbose)
                        .doc("Enable versbosity")
                , clipp::option("-a", "--require-auth")
                        .set(opts.require_authentication)
                        .doc("Require authentication")                
                , clipp::option("--loglevel") & clipp::value("set server's log level", opts.loglevel)
                , clipp::option("-n", "--name") & clipp::value("server name", opts.name)
                );

        if( !clipp::parse(argc, argv, cli) ) {
                std::cout << clipp::make_man_page(cli, argv[0] );
                return EXIT_SUCCESS;
        }

        std::cout << std::boolalpha; 

        std::cout << " Running server " 
                  << " \n         port = " << opts.port 
                  << " \n         host = " << opts.host 
                  << " \n      verbose = " << opts.verbose
                  << " \n require_auth = " << opts.require_authentication
                  << " \n         name = " << opts.name
                  << " \n   log level  = " << opts.loglevel
                  << "\n";

        return EXIT_SUCCESS;
}

$ cmake -H. -B_build -DCMAKE_BUILD_TYPE=Debug 
$ cmake --build _build --target 

 $ ./application 
SYNOPSIS
        ./application <host name> <server port> [-v] [-a] [--loglevel <set server's log level>] [-n
                      <server name>]

OPTIONS
        -v, --verbose
                    Enable versbosity

        -a, --require-auth
                    Require authentication

$ ./application 127.0.0.1 8080 
Running server  
        port = 8080 
        host = 127.0.0.1 
     verbose = false 
require_auth = false 
        name = untitled 
  log level  = 1

$ ./application 127.0.0.1 8080 --verbose --name "lisp server"
Running server  
        port = 8080 
        host = 127.0.0.1 
     verbose = true 
require_auth = false 
        name = lisp server 
  log level  = 1

#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <fstream> // std::ofstream
#include <sstream> // std::stringstream

#include <cereal/archives/binary.hpp>
// #include <cereal/archives/portable_binary.hpp>
#include <cereal/archives/xml.hpp>
#include <cereal/archives/json.hpp>

// Allows std::vector serialization
#include <cereal/types/vector.hpp>

struct DummyClass
{
    double x;
    float  y;
    size_t N;
    std::vector<int> list;

    DummyClass(): x(0), y(0), N(0){ }

    DummyClass(double x, float y, size_t N)
        : x(x), y(y), N(N){ }

    void Add(int x)
    {
        list.push_back(x);
    }

    template<typename Archive>
    void serialize(Archive& archive)
    {
        // Archive without name-value pair
        //--------------------------------
        // archive(x, y, N, list);

        // Archive with name-value pair
        //-------------------------------
        archive(cereal::make_nvp("x", x),
                cereal::make_nvp("y", y),
                cereal::make_nvp("N", N),
                cereal::make_nvp("list", list)
                );
    }

    void show(std::ostream& os)
    {
        os << "DummyClass { x = " << x
           << " ; y = " << y
           << " ; N = " << N
           << " } => ";
        os << " List[ ";
        for(auto const& e: list)
            os << " " << e;
        os << " ] " << "\n";
    }
};


int main()
{
    // ============ Binary Serialization ==================//

    // Memory "file" simulating a disk file
    auto mock_file = std::stringstream{};

    std::cout << "\n=== Experiment 1 - Serialize object to binary file ===\n";
    {
        auto outArchive   = cereal::BinaryOutputArchive(mock_file);
        DummyClass obj{100.6534, 45.5f, 100};
        obj.Add(100); obj.Add(200); obj.Add(50); obj.Add(80);
        outArchive(obj);
        std::cout << " Content of mock-file =  " << mock_file.str() << std::endl;
    }

    std::cout << "\n=== Experiment 2 - Deserialize object from binary file ====\n" ;
    {
        auto inArchive = cereal::BinaryInputArchive(mock_file);
        DummyClass cls;
        inArchive(cls);
        cls.show(std::cout);
    }

    //============= XML Serialization ============================//

    // auto xmlFile = std::ofstream("/tmp/dataset.xml");
    auto xmlFile = std::stringstream{};
    std::cout << "\n=== Experiment 3 - Serialize object to XML file ====\n" ;
    {
        auto outArchive = cereal::XMLOutputArchive(xmlFile);
        DummyClass obj1{200.0, -802.5f, 900};
        obj1.Add(100); obj1.Add(200); obj1.Add(50); obj1.Add(80);
        DummyClass obj2{400.0, -641.f, 300};
        outArchive(obj1, obj2);
    }
    // Note: Cereal uses RAII to flush the archive output, so the output is only
    // guaranteeed to be written to the stream when the archive go out of escope.
    std::cout << " [TRACE] xmlFile = " << xmlFile.str() << std::endl;

    std::cout << "\n=== Experiment 4 - Deserialize object from XML file ===\n" ;
    {
        auto inArchive = cereal::XMLInputArchive(xmlFile);
        DummyClass obj1, obj2;
        // Read two objects from stream
        inArchive(obj1, obj2);
        obj1.show(std::cout);
        obj2.show(std::cout);
    }

    // ============= JSON Serialization =================================//


    // auto xmlFile = std::ofstream("/tmp/dataset.xml");
    auto jsonFile = std::stringstream{};
    std::cout << "\n=== Experiment 5 - Serialize object to JSON file ====\n" ;
    {
        auto outArchive = cereal::JSONOutputArchive(jsonFile);
        DummyClass obj1{200.0, -802.5f, 900};
        obj1.Add(100); obj1.Add(200); obj1.Add(50); obj1.Add(80);
        DummyClass obj2{400.0, -641.f, 300};
        outArchive(cereal::make_nvp("object1", obj1),
                   cereal::make_nvp("object2", obj2));
    }
    std::cout << " [TRACE] JSON File =\n" << jsonFile.str() << std::endl;

    std::cout << "\n=== Experiment 6 - Deserialize object from JSON file ====\n" ;
    {
        auto inArchive = cereal::JSONInputArchive(jsonFile);
        DummyClass obj1, obj2;
        // Read two objects from stream
        inArchive(obj1, obj2);
        obj1.show(std::cout);
        obj2.show(std::cout);
    }

    return 0;
}

$ ./cereal_test.bin

=== Experiment 1 - Serialize object to binary file ===
 Content of mock-file =  6�;N�)Y@��6Bd��������������d�������2���P���

=== Experiment 2 - Deserialize object from binary file ====
DummyClass { x = 100.653 ; y = 45.5 ; N = 100 } =>  List[  100 200 50 80 ]

=== Experiment 3 - Serialize object to XML file ====
 [TRACE] xmlFile = <?xml version="1.0" encoding="utf-8"?>
<cereal>
        <value0>
                <x>200</x>
                <y>-802.5</y>
                <N>900</N>
                <list size="dynamic">
                        <value0>100</value0>
                        <value1>200</value1>
                        <value2>50</value2>
                        <value3>80</value3>
                </list>
        </value0>
        <value1>
                <x>400</x>
                <y>-641</y>
                <N>300</N>
                <list size="dynamic"/>
        </value1>
</cereal>



=== Experiment 4 - Deserialize object from XML file ===
DummyClass { x = 200 ; y = -802.5 ; N = 900 } =>  List[  100 200 50 80 ]
DummyClass { x = 400 ; y = -641 ; N = 300 } =>  List[  ]

=== Experiment 5 - Serialize object to JSON file ====
 [TRACE] JSON File =
{
    "object1": {
        "x": 200.0,
        "y": -802.5,
        "N": 900,
        "list": [
            100,
            200,
            50,
            80
        ]
    },
    "object2": {
        "x": 400.0,
        "y": -641.0,
        "N": 300,
        "list": []
    }
}

=== Experiment 6 - Deserialize object from JSON file ====
DummyClass { x = 200 ; y = -802.5 ; N = 900 } =>  List[  100 200 50 80 ]
DummyClass { x = 400 ; y = -641 ; N = 300 } =>  List[  ]

cmake_minimum_required(VERSION 3.9)
project(YAS_PROJECT)

#========== Global Configurations =============#
#----------------------------------------------#
set(CMAKE_CXX_STANDARD 17)     
set(CMAKE_VERBOSE_MAKEFILE ON)
set(CMAKE_CXX_EXTENSIONS OFF)

#------------- Fetch Serialization Library YAS -------------------#

include( FetchContent )
FetchContent_Declare( yas
    GIT_REPOSITORY  "https://github.com/niXman/yas.git"
    GIT_TAG         "7.0.4"
)
FetchContent_MakeAvailable(yas)
include_directories("${yas_SOURCE_DIR}/include/" )

#========== Targets Configurations ============#

add_executable(executable serialize.cpp)

#include <iostream>
#include <deque>
#include <algorithm>
#include <numeric>
#include <initializer_list>
#include <fstream>

#include <yas/serialize.hpp>
#include <yas/std_types.hpp>
#include <yas/text_iarchive.hpp>
#include <yas/text_oarchive.hpp>

/** @brief Read whole input stream to a string and returns it
  * Requires headers: <iostream> and <sstream>
  */
std::string
istreamToString(std::istream& is){
    if(is.bad()){
        throw std::runtime_error("Error: stream has errors.");
    }
    std::stringstream ss;
    ss << is.rdbuf();
    return ss.str();
}

class Stats
{

    std::string m_name = "";
    std::deque<double> m_data = {};
public:
    Stats() { }

    Stats(std::initializer_list<double> const& list)
        : m_data(list.begin(), list.end()) { }

    void   insert(double x){ m_data.push_back(x); }
    double get(size_t index) const { return m_data[index]; }
    size_t size()            const { return m_data.size(); }
    auto begin() { return m_data.begin(); }
    auto end()   { return m_data.end();   }

    std::string name() const { return m_name; }
    void set_name(std::string name) { m_name = name; }

    double mean() const {
        double total = std::accumulate(m_data.begin(), m_data.end(), 0.0);
        return total / m_data.size();
    }

    double first() const { return m_data.front(); }
    double last()  const{ return m_data.back(); }

    /** Required friend function for making class printable */
    friend std::ostream& operator<<(std::ostream& os, const Stats& stat)
    {
        os <<  "Stats { name = '" << stat.m_name << "' ; data = [ ";
        for(auto x: stat.m_data) { os << x << ", "; }
        return os << " ] }";
    }

    /** Required method for making the class serializable */
    template<typename Archive>
    void serialize(Archive& ar)
    {
        // NVP => Name-value-pair
        ar & YAS_OBJECT_NVP(
              "Stats"
            ,("name", m_name)
            ,("data", m_data)
            );
    }

};


int main()
{

    const char* jsonfile = "program_data.json";

    std::cout << "\n ==== EXPERIMENT 1 ====== Save data to file ========\n\n";

    {
        auto stats = Stats{4.5, -10.3, 58.66, 10.6, 9.615, 56.156, 90.51, -62.0};
        stats.set_name("Price change");

        // std::cout << " => Name " << stats.name() << std::endl;
        std::cout << "   => stats = " << stats << std::endl;
        std::cout << "   =>  mean = " << stats.mean() << std::endl;

        // Remove file if it exists
        std::remove(jsonfile);

        // Save archive data in a JSON file
        yas::save<yas::file | yas::json>(jsonfile, stats);
    }

    // Check file content
    auto ifs = std::ifstream{jsonfile};
    auto content = istreamToString(ifs);
    std::cout << "\n File content = \n " << content
              << std::endl;

    std::cout << "\n ==== EXPERIMENT 2 ====== Load data from file ======\n\n";

    {
        auto statsB = Stats{};
        yas::load<yas::file | yas::json>(jsonfile, statsB);
        std::cout << "   => stats = " << statsB << std::endl;
        std::cout << "   =>  mean = " << statsB.mean() << std::endl;
    }

    std::cout << "\n ==== EXPERIMENT 3 ====== Load/Save data from memory ======\n\n";

    // Save to memory
    yas::mem_ostream os;

    auto statsX = Stats{14.5, 25.16, 18.66, -10.6, 62.615, +46.1566, 90.51, 62.61};
    statsX.set_name("Oil prices");
    {
        auto archive = yas::binary_oarchive<yas::mem_ostream>(os);
        archive(statsX);
        std::cout << " StatsX = " << statsX << std::endl;
        std::cout << " [TRACE] Saved to memory OK." << std::endl;
    }

    {
        auto is = yas::mem_istream(os.get_intrusive_buffer());
        auto archive = yas::binary_iarchive<yas::mem_istream>(is);
        auto statsY = Stats();
        archive(statsY);
        std::cout << " [TRACE] Load from memory OK." << std::endl;
        std::cout << " StatsY = " << statsY << std::endl;
    }

    return 0;
}

==== EXPERIMENT 1 ====== Save data to file ========

  => stats = Stats { name = 'Price change' ; data = [ 4.5, -10.3, 58.66, 10.6, 9.615, 56.156, 90.51, -62,  ] }
  =>  mean = 19.7176

File content = 
{"name":"Price change","data":[4.5,-10.3,58.66,10.6,9.615,56.156,90.51,-62.0]}

==== EXPERIMENT 2 ====== Load data from file ======

  => stats = Stats { name = 'Price change' ; data = [ 4.5, -10.3, 58.66, 10.6, 9.615, 56.156, 90.51, -62,  ] }
  =>  mean = 19.7176

==== EXPERIMENT 3 ====== Load/Save data from memory ======

StatsX = Stats { name = 'Oil prices' ; data = [ 14.5, 25.16, 18.66, -10.6, 62.615, 46.1566, 90.51, 62.61,  ] }
[TRACE] Saved to memory OK.
[TRACE] Load from memory OK.
StatsY = Stats { name = 'Oil prices' ; data = [ 14.5, 25.16, 18.66, -10.6, 62.615, 46.1566, 90.51, 62.61,  ] }

#include <iostream>
#include <iomanip>

#include <tinyxml2.h>

#define ENABLE_ASSERT

#ifdef ENABLE_ASSERT
#define M_ASSERT(expr) \
      { \
         if(!(expr)){ \
            std::cerr << "ASSERTION FAILURE: \n"; \
            std::cerr << " => Condition: " << #expr << "\n"; \
            std::cerr << " =>  Function: " << __FUNCTION__ << "\n"; \
            std::cerr << __FILE__ << ":" << __LINE__ << ":" << "\n"; \
            std::terminate(); \
         } \
      }
#else
#define M_ASSERT(expr)
#endif

using tinyxml2::XMLText;
using tinyxml2::XMLElement;
using tinyxml2::XMLNode;

extern const char* exchangeRatesXML;

int main()
{

    std::cout << " [INFO] Running TinyXMl2 " << std::endl;

    tinyxml2::XMLDocument doc;

    if(doc.Parse( exchangeRatesXML) != tinyxml2::XML_SUCCESS)
    {
        std::cout << " [ERROR] Failed to parse XML" << std::endl;
        return EXIT_FAILURE;
    }
    std::cout << " [OK] XML parsed successfully" << std::endl;


    tinyxml2::XMLPrinter printer;
    doc.Print(&printer);

    std::cout << "Value: doc.FirstChild()->Value() = " << doc.FirstChild()->Value() << std::endl;

    XMLElement* elem = doc.FirstChildElement("gesmes:Envelope");
    M_ASSERT(elem != nullptr);
    if(elem){
        std::cout << " Element found. OK " << std::endl;
        std::cout << " =>> Element Name = " << elem->Name() << std::endl;

    }

    XMLElement* elem1 = elem->FirstChildElement("Cube");
    M_ASSERT(elem1 != nullptr);

    std::cout << " =>> Found Node Name: " << elem1->ToElement()->Name() << "\n";

    XMLElement* elem2 = elem1->FirstChildElement("Cube");
    M_ASSERT(elem2 != nullptr);

    const char* time = elem2->Attribute("time");
    M_ASSERT(time != nullptr);

    // XML node with: <Cube time = 'xxxx-xx-xx'>
    std::cout << " => Time = " << time << "\n\n";
    std::cout << std::fixed << std::setprecision(3);

    std::cout << " ===== Exchange rates per Euro ====" << std::endl;

    for(XMLElement* e = elem2->FirstChildElement("Cube")
             ; e != nullptr; e = e->NextSiblingElement("Cube") )
    {
        std::cout << std::setw(10) << e->Attribute("currency")
                  << std::setw(15) << std::stod(e->Attribute("rate"))
                  << std::endl;
    }


    return doc.ErrorID();
}

// Source: https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml
const char* exchangeRatesXML = R"(
   <?xml version="1.0" encoding="UTF-8"?>
   <gesmes:Envelope 
                xmlns:gesmes="http://www.gesmes.org/xml/2002-08-01" 
                xmlns="http://www.ecb.int/vocabulary/2002-08-01/eurofxref">

           <gesmes:subject>Reference rates</gesmes:subject>
           <gesmes:Sender>
                   <gesmes:name>European Central Bank</gesmes:name>
           </gesmes:Sender>
           <Cube>
                   <Cube time='2019-06-14'>
                           <Cube currency='USD' rate='1.1265'/>
                           <Cube currency='JPY' rate='121.90'/>
                           <Cube currency='BGN' rate='1.9558'/>
                           <Cube currency='CZK' rate='25.540'/>
                           <Cube currency='DKK' rate='7.4676'/>
                           <Cube currency='GBP' rate='0.89093'/>
                           <Cube currency='HUF' rate='321.53'/>
                           <Cube currency='PLN' rate='4.2534'/>
                           <Cube currency='RON' rate='4.7233'/>
                           <Cube currency='SEK' rate='10.6390'/>
                           <Cube currency='CHF' rate='1.1211'/>
                           <Cube currency='ISK' rate='141.50'/>
                           <Cube currency='NOK' rate='9.7728'/>
                           <Cube currency='HRK' rate='7.4105'/>
                           <Cube currency='RUB' rate='72.3880'/>
                           <Cube currency='TRY' rate='6.6427'/>
                           <Cube currency='AUD' rate='1.6324'/>
                           <Cube currency='BRL' rate='4.3423'/>
                           <Cube currency='CAD' rate='1.5018'/>
                           <Cube currency='CNY' rate='7.7997'/>
                           <Cube currency='HKD' rate='8.8170'/>
                           <Cube currency='IDR' rate='16128.10'/>
                           <Cube currency='ILS' rate='4.0518'/>
                           <Cube currency='INR' rate='78.6080'/>
                           <Cube currency='KRW' rate='1333.60'/>
                           <Cube currency='MXN' rate='21.6073'/>
                           <Cube currency='MYR' rate='4.6981'/>
                           <Cube currency='NZD' rate='1.7241'/>
                           <Cube currency='PHP' rate='58.539'/>
                           <Cube currency='SGD' rate='1.5403'/>
                           <Cube currency='THB' rate='35.101'/>
                           <Cube currency='ZAR' rate='16.6529'/>
                   </Cube>
           </Cube>
   </gesmes:Envelope>
)";

cmake_minimum_required(VERSION 3.9)
project(tinyxml2-test)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)

#=========== Conan Bootstrap =================#

# Download automatically, you can also just copy the conan.cmake file
if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
   message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
   file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.13/conan.cmake"
                 "${CMAKE_BINARY_DIR}/conan.cmake")
endif()

include(${CMAKE_BINARY_DIR}/conan.cmake)
set(CONAN_PROFILE default)

conan_cmake_run( REQUIRES
                 tinyxml2/7.0.1@nicolastagliani/stable
                 BASIC_SETUP
                 BUILD missing )

#=========== Find Package ================#

include(tinyxml2_helper.cmake)

#=========== Targets =====================# 

add_executable(tinyxml2-test tinyxml2-test.cpp)
target_link_libraries(tinyxml2-test PRIVATE ${tinyxml2_LIBRARY})

# Credits: https://github.com/nicolastagliani/conan-tinyxml2/issues/3
include( FindPackageHandleStandardArgs )

find_path( tinyxml2_INCLUDE_DIR
  NAMES
    tinyxml2.h
  PATHS
    ${CONAN_INCLUDE_DIRS_TINYXML2}
)

find_library( tinyxml2_LIBRARY
  NAMES
    ${CONAN_LIBS_TINYXML2}
  PATHS
    ${CONAN_LIB_DIRS_TINYXML2}
)

find_package_handle_standard_args( tinyxml2 DEFAULT_MSG
  tinyxml2_INCLUDE_DIR
)

if( tinyxml2_FOUND )
  set( tinyxml2_INCLUDE_DIRS ${tinyxml2_INCLUDE_DIR} )
  set( tinyxml2_LIBRARIES ${tinyxml2_LIBRARY} )

  get_filename_component( tinyxml2_CONFIG_PATH ${CONAN_TINYXML2_ROOT} DIRECTORY )
  get_filename_component( tinyxml2_HASH ${CONAN_TINYXML2_ROOT} NAME )
  get_filename_component( tinyxml2_CONFIG_PATH ${tinyxml2_CONFIG_PATH} DIRECTORY )
  set( tinyxml2_CONFIG_PATH  ${tinyxml2_CONFIG_PATH}/build/${tinyxml2_HASH} )
  set( tinyxml2_CONFIG_FILENAME tinyxml2Config.cmake )

  find_file( tinyxml2_CONFIG_DIR
      ${tinyxml2_CONFIG_FILENAME}
    HINTS
      ${tinyxml2_CONFIG_PATH}
  )

  if( tinyxml2_CONFIG_DIR-NOTFOUND )
    set( tinyxml2_CONFIG "" )
  else()
    set( tinyxml2_CONFIG ${tinyxml2_CONFIG_DIR} )
  endif()

  mark_as_advanced(
    tinyxml2_INCLUDE_DIR
    tinyxml2_LIBRARY
    tinyxml2_DIR
    tinyxml2_CONFIG
  )
else()
  set( tinyxml2_DIR "" CACHE STRING
    "An optional hint to a tinyxml2 directory"
  )
endif()

$ git clone https://gist.github.com/caiorss/351e291b8df2b0fc8e1bba5c86b7ee4d gist 
$ cd gist 

# Build with QT Creator 
$ qtcreator CMakeLists.txt 

# Build from command line 
$ cmake -H. -Bbuild -DCMAKE_BUILD_TYPE=Debug
$ cmake --build build --target

$ build/bin/tinyxml2-test 

 [INFO] Running TinyXMl2 
 [OK] XML parsed successfully
Value: doc.FirstChild()->Value() = xml version="1.0" encoding="UTF-8"
 Element found. OK 
 =>> Element Name = gesmes:Envelope
 =>> Found Node Name: Cube
 => Time = 2019-06-14

 ===== Exchange rates per Euros ====
       USD          1.127
       JPY        121.900
       BGN          1.956
       CZK         25.540
       DKK          7.468
       GBP          0.891
       HUF        321.530
       PLN          4.253
       RON          4.723
       SEK         10.639
       CHF          1.121
       ISK        141.500
       NOK          9.773
       HRK          7.410
       RUB         72.388
       TRY          6.643
       AUD          1.632
       BRL          4.342
       CAD          1.502
       CNY          7.800
       HKD          8.817
       IDR      16128.100
       ILS          4.052
       INR         78.608
       KRW       1333.600
       MXN         21.607
       MYR          4.698
       NZD          1.724
       PHP         58.539
       SGD          1.540
       THB         35.101
       ZAR         16.653

#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>

#include <pugixml.hpp>

extern const char* exchangeRatesXML;

int main()
{
    // This input stream 'is' can be replaced by
    // any other input stream without any code modification
    // such as:  std::ifstream is("/tmp/input-file.xml")
    std::stringstream is{exchangeRatesXML};

    pugi::xml_document     doc;
    pugi::xml_parse_result result = doc.load(is);

    if(!result){
        std::cerr << " [ERROR] Failed to parse the XML. Invalid file." << std::endl;
        std::exit(EXIT_FAILURE);
    }

    std::string sender_name = doc.child("gesmes:Envelope")
                                  .child("gesmes:Sender")
                                  .child_value("gesmes:name");

    // type: const char*
    auto subject = doc.child("gesmes:Envelope")
                      .child_value("gesmes:subject");

    auto time = doc.child("gesmes:Envelope")
                   .child("Cube")
                   .child("Cube").attribute("time")
                   .value();

    std::cout << " ========= DOCUMENT INFO ================" << std::endl;
    std::cout << " => Sender name = " << sender_name << std::endl;
    std::cout << " =>     Subject = " << subject << std::endl;
    std::cout << " =>        Time = " << time << std::endl;

    auto parent = doc.child("gesmes:Envelope")
                              .child("Cube")
                              .child("Cube");

    std::cout << std::fixed << std::setprecision(3);

    std::cout <<"\n Exchange Rates per EURO " << std::endl;

    for(auto const& node : parent)
    {
        std::cout << std::setw(10) << node.attribute("currency").value()
                  << std::setw(10) << std::stod(node.attribute("rate").value())
                  << std::endl;
    }

    std::cout << "\n\n *********** Extracting Data with XPATH ********\n\n";

    pugi::xpath_node sender_name2 = doc.select_node("//gesmes:name");
    std::cout << " Sender = " << sender_name2.node().child_value() << std::endl;

    auto time2 = doc.select_node("//Cube[@time]");
    std::cout << " Time = " << time2.node().attribute("time").value() << std::endl;

    std::cout <<"\n Exchange Rates per EURO - Extracted with XPATH " << std::endl;

    // Type: pugi::xpath_node_set
    auto dataNodes = doc.select_nodes("/gesmes:Envelope/Cube/Cube/Cube");

    for(auto const& n : dataNodes)
    {
        std::cout << std::setw(10) << n.node().attribute("currency").value()
                  << std::setw(10) << std::stod(n.node().attribute("rate").value())
                  << std::endl;
    }


    return 0;
}


// Source: https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml
const char* exchangeRatesXML = R"(
   <?xml version="1.0" encoding="UTF-8"?>
   <gesmes:Envelope
                xmlns:gesmes="http://www.gesmes.org/xml/2002-08-01"
                xmlns="http://www.ecb.int/vocabulary/2002-08-01/eurofxref">

       <gesmes:subject>Reference rates</gesmes:subject>
       <gesmes:Sender>
           <gesmes:name>European Central Bank</gesmes:name>
       </gesmes:Sender>
       <Cube>
           <Cube time='2019-06-14'>
               <Cube currency='USD' rate='1.1265'/>
               <Cube currency='JPY' rate='121.90'/>
               <Cube currency='BGN' rate='1.9558'/>
               <Cube currency='CZK' rate='25.540'/>
               <Cube currency='DKK' rate='7.4676'/>
               <Cube currency='GBP' rate='0.89093'/>
               <Cube currency='HUF' rate='321.53'/>
               <Cube currency='PLN' rate='4.2534'/>
               <Cube currency='RON' rate='4.7233'/>
               <Cube currency='SEK' rate='10.6390'/>
               <Cube currency='CHF' rate='1.1211'/>
               <Cube currency='ISK' rate='141.50'/>
               <Cube currency='NOK' rate='9.7728'/>
               <Cube currency='HRK' rate='7.4105'/>
           </Cube>
       </Cube>
   </gesmes:Envelope>
)";

cmake_minimum_required(VERSION 3.9)
project(purgixml)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)

# ============= Conan Boosttrap =========================#

# Download automatically, you can also just copy the conan.cmake file
if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
   message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
   file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.13/conan.cmake"
                 "${CMAKE_BINARY_DIR}/conan.cmake")
endif()

include(${CMAKE_BINARY_DIR}/conan.cmake)

# Possible values "default" and "llvm8"
set(CONAN_PROFILE default)

conan_cmake_run(REQUIRES
                  pugixml/1.9@bincrafters/stable
                BASIC_SETUP
                BUILD missing)

# ============= Find Package ===========================#

find_package(pugixml REQUIRED)

#============= Targets Settings ========================#

add_executable(pugixml_test1 pugixml_test1.cpp)
target_link_libraries(pugixml_test1 pugixml)

========= DOCUMENT INFO ================
 => Sender name = European Central Bank
 =>     Subject = Reference rates
 =>        Time = 2019-06-14

 Exchange Rates per EURO 
       USD     1.127
       JPY   121.900
       BGN     1.956
       CZK    25.540
       DKK     7.468
       GBP     0.891
       HUF   321.530
       PLN     4.253
       RON     4.723
       SEK    10.639
       CHF     1.121
       ISK   141.500
       NOK     9.773
       HRK     7.410


 *********** Extracting Data with XPATH ********

 Sender = European Central Bank
 Time = 2019-06-14

 Exchange Rates per EURO - Extracted with XPATH 
       USD     1.127
       JPY   121.900
       BGN     1.956
       CZK    25.540
       DKK     7.468
       GBP     0.891
       HUF   321.530
       PLN     4.253
       RON     4.723
       SEK    10.639
       CHF     1.121
       ISK   141.500
       NOK     9.773
       HRK     7.410

cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
project(cppjson)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)

# ============= Conan Bootstrap =============================#

# Download automatically, you can also just copy the conan.cmake file
if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
   message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
   file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.13/conan.cmake"
                 "${CMAKE_BINARY_DIR}/conan.cmake")
endif()

include(${CMAKE_BINARY_DIR}/conan.cmake)

conan_cmake_run(REQUIRES     
                             jsonformoderncpp/3.7.0@vthiery/stable
                BASIC_SETUP
                BUILD missing
                )
#===== Targets ===========================#

# Conan package: jsonformoderncpp/3.7.0@vthiery/stable
find_package(nlohmann_json 3.2.0 REQUIRED)
add_executable(json-parse  json-parse.cpp)
target_link_libraries(json-parse nlohmann_json::nlohmann_json)

cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
project(cmake-experiment)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)

macro(Download_Single_Headerlib_dir FILE PATH URL)
    file(DOWNLOAD ${URL} ${CMAKE_BINARY_DIR}/include/${PATH}${FILE})
    IF(NOT Download_Single_Headerlib_flag)
       include_directories(${CMAKE_BINARY_DIR}/include)
       set(Download_Single_Headerlib_flag TRUE)
    ENDIF()
endmacro()

# #include <nlohmann/json.hpp>
Download_Single_Headerlib_dir(
     json.hpp "nlohmann/"
    "https://github.com/nlohmann/json/raw/develop/single_include/nlohmann/json.hpp"
)

# --------------------------------------------#

add_executable(json-parse json-parse.cpp)

#include <iostream>
#include <sstream>

#include <nlohmann/json.hpp>

using json = nlohmann::json;

int main()
{
    std::puts("\n====== EXPERIMETN 1 - Create JSON Object ===========================");

    {
        json top;
        top["hero1"] = "John Von Neumman / Modern Computers";
        top["hero2"] = "Dennis Ritchie / C Language";
        top["points"] = 200;
        top["list_number"]  = {1, 2, 3, 3, 4, 5, 6};
        top["list_string"]  = {"Rice", "Coffee", "Beans", "Milk"};

        top["currency_basket"] = {{"USD", 10}, {"BRL", 2000}, {"CAD", 90}, {"AUD", "N/A"}};

        json cd;
        cd["latitude"]  = -23.5505;
        cd["longitude"] = -46.6333;
        cd["location"]  = "São Paulo city";

        top["coordiante"] = cd;

        std::cout << "\n VALUE OF JSON [NOT PRETTY PRINT] = "
                  << top << std::endl;

        std::cout << "\n VALUE OF JSON [PRETTY PRINT] = "
                  << top.dump(4) << std::endl;

    }

     std::puts("\n====== EXPERIMETN 2 - Deserialization from string literal ===========");

     {
         json d;

         try {
             // Parsing from string literal
             d = R"(
                      {
                        "x"            : 1956.2322
                      , "y"            : 1000
                      , "name"        : "Dennis Ritchie"
                      , "fruits" : [ "orange", "jabuticaba", "banana", "apple"  ]
                      , "basket" : { "BONDS": 1235, "CDS": 200.354, "FX": 500
                                     , "market": "Emergin Markets"}
                     }
               )"_json;
         } catch(nlohmann::detail::parse_error& ex)
         {
             std::cout << " [ERROR] I cannot parse it: " << ex.what() << std::endl;
         }

         std::cout << "\n VALUE OF JSON PRETTY PRINT = " << d.dump(3) << std::endl;

         std::cout << " [RESULT]    x = " << static_cast<double>(d["x"]) << std::endl;
         std::cout << " [RESULT]    x = " << d["x"].get<double>() << std::endl;
         std::cout << " [RESULT]    y = " << d["y"].get<int>()    << std::endl;
         std::cout << " [RESULT] name = " << d["name"].get<std::string>() << std::endl;

         std::cout << " [RESULT] fruit[0] = " << d["fruits"][0] << std::endl;
         std::cout << " [RESULT] fruit[1] = " << d["fruits"][1] << std::endl;
         std::cout << " [RESULT] fruit[2] = " << d["fruits"][2].get<std::string>() << std::endl;

         std::cout << " [RESULT]  d['basket']['BONDS'] = "
                   << d["basket"]["BONDS"].get<int>()
                   << std::endl;

         std::cout << " [RESULT]  d['basket']['CDS'] = "
                   << d["basket"]["CDS"].get<double>()
                   << std::endl;

         std::cout << " [RESULT]  d['basket']['market'] = "
                   << d["basket"]["market"].get<std::string>()
                   << std::endl;

         // Attempt to generate a parser error
         try
         {
             // Note: Expects failure, the exception will be thrown!
             double value = static_cast<double>(d["name"]);
             std::cout << " [RESULT]  2 *  x = " <<  2 * value
                       << "\n\n";
         } catch (nlohmann::detail::type_error& ex)
         {
             std::cout << " [ERROR] err = " << ex.what() << std::endl;
         }


     }

     std::puts("\n====== EXPERIMETN 3 - Deserialization from stream ===========");
     {
         const char* json_text = R"(
                      {
                        "x"            : 1956.2322
                      , "y"            : 1000
                      , "flag"         : true
                      , "name"         : "Dennis Ritchie"
                      , "asset_basket" : { "CAD": 100, "BRL": 200, "USD": 500}
                     }
               )";

         json js;
         /* Input stream could be a file:
          *     auto is = std::ifstream("/tmp/file");
          *------------------------------------------*/
         auto is = std::stringstream(json_text);
         is >> js; // Extract from memory stream

         std::cout << std::boolalpha;
         std::cout << " JSON VALUE = " << js.dump(4) << std::endl;

         std::cout << " =>      is_null(x) = " << js["x"].is_null()    << std::endl;
         std::cout << " =>   is_boolean(x) = " << js["x"].is_boolean() << std::endl;
         std::cout << " =>    is_number(x) = " << js["x"].is_number()  << std::endl;
         std::cout << " => is_string(name) = " << js["name"].is_string()  << std::endl;

         std::cout << " =>    is_string(asset_basket) = "
                   << js["asset_basket"].is_string() << std::endl;

         std::cout << " =>    is_object(asset_basket) = "
                   << js["asset_basket"].is_object()  << std::endl;

         std::puts("\n  >>>--|>>> Iterate Over JSON AST - Abstract Syntax Tree <<<|---<<< ");

         for(auto const& element: js)
             std::cout << " => element = " << element << std::endl;

     }
}

====== EXPERIMETN 1 - Create JSON Object ===========================

 VALUE OF JSON [NOT PRETTY PRINT] = {"coordiante":{"latitude":-23.5505,"location":"São Paulo city","longitude":-46.6333}, ....}

 VALUE OF JSON [PRETTY PRINT] = {
    "coordiante": {
        "latitude": -23.5505,
        "location": "São Paulo city",
        "longitude": -46.6333
    },
    "currency_basket": {
        "AUD": "N/A",
        "BRL": 2000,
        "CAD": 90,
        "USD": 10
    },
    "hero1": "John Von Neumman / Modern Computers",
    "hero2": "Dennis Ritchie / C Language",
    "list_number": [
        1,
        2,
        3,
        3,
        4,
        5,
        6
    ],
    "list_string": [
        "Rice",
        "Coffee",
        "Beans",
        "Milk"
    ],
    "points": 200
}

====== EXPERIMETN 2 - Deserialization from string literal ===========

 VALUE OF JSON PRETTY PRINT = {
   "basket": {
      "BONDS": 1235,
      "CDS": 200.354,
      "FX": 500,
      "market": "Emergin Markets"
   },
   "fruits": [
      "orange",
      "jabuticaba",
      "banana",
      "apple"
   ],
   "name": "Dennis Ritchie",
   "x": 1956.2322,
   "y": 1000
}
 [RESULT]    x = 1956.23
 [RESULT]    x = 1956.23
 [RESULT]    y = 1000
 [RESULT] name = Dennis Ritchie
 [RESULT] fruit[0] = "orange"
 [RESULT] fruit[1] = "jabuticaba"
 [RESULT] fruit[2] = banana
 [RESULT]  d['basket']['BONDS'] = 1235
 [RESULT]  d['basket']['CDS'] = 200.354
 [RESULT]  d['basket']['market'] = Emergin Markets
 [ERROR] err = [json.exception.type_error.302] type must be number, but is string

====== EXPERIMETN 3 - Deserialization from stream ===========
 JSON VALUE = {
    "asset_basket": {
        "BRL": 200,
        "CAD": 100,
        "USD": 500
    },
    "flag": true,
    "name": "Dennis Ritchie",
    "x": 1956.2322,
    "y": 1000
}
 =>      is_null(x) = false
 =>   is_boolean(x) = false
 =>    is_number(x) = true
 => is_string(name) = true
 =>    is_string(asset_basket) = false
 =>    is_object(asset_basket) = true

  >>>--|>>> Iterate Over JSON AST - Abstract Syntax Tree <<<|---<<< 
 => element = {"BRL":200,"CAD":100,"USD":500}
 => element = true
 => element = "Dennis Ritchie"
 => element = 1956.2322
 => element = 1000

$ cd <PROJECT_DIR> 
$ curl -O -L https://raw.githubusercontent.com/skystrife/cpptoml/v0.1.1/include/cpptoml.h

#include <iostream>
#include <string>
#include <sstream>

#include <cpptoml.h>

template <typename T>
using sh = std::shared_ptr<T>;

extern const char* tomlData;


void parseConfiguration(std::istream& is)
{
    cpptoml::parser p{is};
    sh<cpptoml::table> config = p.parse();

    std::cout << "\n --- TOML Configuration data read from input stream ------\n";

    int loglevel  = config->get_qualified_as<int>("INFO.loglevel").value_or(0);
    auto userName = config->get_qualified_as<std::string>("INFO.user").value_or("unnamed");
    auto file     = config->get_qualified_as<std::string>("INFO.file").value_or("");
    auto port     = config->get_qualified_as<int>("SERVER.port").value_or(8080);
    std::cout << " => loglevel = " << loglevel << "\n"
              << " => userName = " << userName << "\n"
              << " => file     = " << file << "\n"
              << " => port     = " << port << "\n";

    auto locations = config->get_qualified_array_of<std::string>("SERVER.directories");
    if(!locations)
    {
        std::cerr << " [ERROR] SERVER.directories not found." << std::endl;
    }
    for(auto const& path: *locations)
    {
        std::cout << " path: " << path << std::endl;
    }

}

int main(int argc, char** argv)
{
    if(argc == 1){
        std::cerr << " Error: invalid option " << std::endl;
        return EXIT_FAILURE;
    }

    std::string cmd = argv[1];
    if(cmd == "-stream")
    {
        auto is = std::stringstream(tomlData);
        parseConfiguration(is);

        return EXIT_SUCCESS;
    }

    if(cmd == "-file"  && argc == 3)
    {
        auto is = std::ifstream(argv[2]);
        if(!is){
            std::cerr << "Error: file not found." << std::endl;
            std::exit(EXIT_FAILURE);
        }
        parseConfiguration(is);
        return EXIT_SUCCESS;
    }

    std::cerr << " Error: invalid option. " << std::endl;

    return 0;
}

const char* tomlData = R"(
[INFO]
 loglevel = 10
 user     = "Dummy user"
 file     = "C:\\Users\\somebody\\storage\\data.log"

[SERVER]
  host = "127.0.0.1"
  port = 9090
  directories = [
      "C:\\Users\\somebody\\Document"
     ,"C:\\Users\\somebody\\Upload"
     ,"C:\\Users\\somebody\\Pictures"
  ]

)";

[INFO]
 loglevel = 0 
 user     = "Admin User"
 file     = "C:\\Users\\admin\\files\\log.txt"

[SERVER]
  host = "0.0.0.0"
  port = 9060
  directories = [
      "/Users/admin/Desktop"
      ,"/Applications"
      ,"/Frameworks"
      ,"/tmp"
  ]

$ g++ main.cpp -o main.bin -std=c++1z -g -O0 -Wall -Wextra -pedantic

# Mesaure compile-time 
$ time g++ main.cpp -o main.bin -std=c++1z -g -O0 -Wall -Wextra -pedantic

real    0m2.462s
user    0m2.262s
sys     0m0.172s

$ ./main.bin -stream

 --- TOML Configuration data read from input stream ------
 => loglevel = 10
 => userName = Dummy user
 => file     = C:\Users\somebody\storage\data.log
 => port     = 9090
 path: C:\Users\somebody\Document
 path: C:\Users\somebody\Upload
 path: C:\Users\somebody\Pictures

$ ./main.bin -file server.conf

 --- TOML Configuration data read from input stream ------
 => loglevel = 0
 => userName = Admin User
 => file     = C:\Users\admin\files\log.txt
 => port     = 9060
 path: /Users/admin/Desktop
 path: /Applications
 path: /Frameworks
 path: /tmp

$ git clone https://gist.github.com/caiorss/eb2fc15b7ed322ccac5ee496585e54e9 gist && cd gist
Cloning into 'gist'...
remote: Enumerating objects: 4, done.
remote: Counting objects: 100% (4/4), done.
remote: Compressing objects: 100% (4/4), done.
remote: Total 4 (delta 0), reused 0 (delta 0), pack-reused 0
Unpacking objects: 100% (4/4), done.

$ ls
CMakeLists.txt  gtest-experiment.cpp

# Open with QT Creator, Visual Studio or build from command line 
$ qtcreator CMakeList.txt 

# Open with Visual Studio 
$ devenv CMakeLists.txt 

#include <iostream>
#include <string>
#include <vector>
#include <cassert>

#include <gtest/gtest.h>

// ==================== Implementation ========================

int factorial(int n){
    int prod = 1;
    for(int i = 1; i <= n; i++)
        prod *= i;
    return prod;
}

struct Date
{
    int year;
    int month;
    int day;
    Date(){}
    Date(int year, int month, int day)
        : year(year)
        , month(month)
        , day(day)
    { }

    // Comparison operator required by  EXPECT_EQ
    bool operator==(Date const& rhs) const
    {
        return year  == rhs.year
            && month == rhs.month
            && day   == rhs.day;
    }
    // Necessary for make class printable in GTest
    friend std::ostream& operator<<(std::ostream& os, Date const& rhs)
    {
        return os << "Date { " << rhs.year << " ; "
                  << rhs.month << " ; "
                  << rhs.day << " } ";
    }
};

Date GregorianEasterSunday(int y)
{
    int c = y / 100;
    int n = y - 19 * ( y / 19 );
    int k = ( c - 17 ) / 25;
    int i = c - c / 4 - ( c - k ) / 3 + 19 * n + 15;
    i = i - 30 * ( i / 30 );
    i = i - ( i / 28 ) * ( 1 - ( i / 28 )
          * ( 29 / ( i + 1 ) )
          * ( ( 21 - n ) / 11 ) );
    int j = y + y / 4 + i + 2 - c + c / 4;
    j = j - 7 * ( j / 7 );
    int l = i - j;
    int m = 3 + ( l + 40 ) / 44;
    int d = l + 28 - 31 * ( m / 4 );
    return Date(y, m, d);
}

//=============== Tests ====================================//

TEST(FactorialTest, test1){
    EXPECT_EQ(6,        factorial(3));
    EXPECT_EQ(24,       factorial(4));
    EXPECT_EQ(120,      factorial(5));
    EXPECT_EQ(3628800,  factorial(10));
    // Expect greater than
    EXPECT_GT(10000000, factorial(10));
    // Expect not equal
    EXPECT_NE(25, factorial(4));
}

TEST(FactorialTestFailure, testFailure){
    // Deliberately fails for demonstration purposes
    EXPECT_EQ(6, factorial(3));
    EXPECT_EQ(4, factorial(4));
    EXPECT_EQ(6, factorial(2));
}

TEST(GregorianEaster, testdates){
    EXPECT_EQ(Date(2005, 3, 27), GregorianEasterSunday(2005));
    EXPECT_EQ(Date(2008, 3, 23), GregorianEasterSunday(2008));
    EXPECT_EQ(Date(2010, 4, 4),  GregorianEasterSunday(2010));
}

cmake_minimum_required(VERSION 3.9)
project( GtestsExperiment
         VERSION      0.1
         DESCRIPTION  "Experiment with Gtest uni testing framework"
        )
# ============= Conan Bootstrap =============================#

# Download automatically, you can also just copy the conan.cmake file
if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
   message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
   file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.13/conan.cmake"
                 "${CMAKE_BINARY_DIR}/conan.cmake")
endif()

include(${CMAKE_BINARY_DIR}/conan.cmake)

conan_cmake_run(REQUIRES
                gtest/1.8.1@bincrafters/stable
                BASIC_SETUP
                BUILD missing
                )

#============= Find Packages ================================#

find_package(GTest REQUIRED)

#---------------------------------------------------#
#             Targets Settings                      #
#---------------------------------------------------#

add_executable(gtest-experiment gtest-experiment.cpp)
target_link_libraries(gtest-experiment GTest::GTest GTest::Main)
add_test(GTestExperiment gtest-experiment)

#include <iostream>

#include <catch2/catch.hpp>


int formula(int x, int y)
{
    return 4 * x + 2 * y;
}

TEST_CASE("Test function furmula A", "[tag1]")
{
    REQUIRE( formula(3, 4) == 20 );
    REQUIRE( formula(4, 5) == 26 );
}

TEST_CASE("Test function formula B", "[tag2]")
{
    REQUIRE( formula(0, 0) == 0  );
    // Intentionally fails
    REQUIRE( formula(2, 5) == 10 );
}


struct TestData
{
    int x, y, expected;
};


TEST_CASE("Testing with struct")
{
    auto t = GENERATE( values<TestData>(
    {
        {3,  4, 20}
       ,{4,  5, 26}
       ,{0,  0,  0}
       ,{-1, 4,  6} // Fails
       ,{ 2, 2, 12}
    }));
    REQUIRE( formula(t.x, t.y) == t.expected);
}


TEST_CASE("Testing with structured bindings")
{
    auto [x, y, z] = GENERATE( table<int, int, int>(
    {
        {3,  4, 20}
       ,{4,  5, 26}
       ,{0,  0,  0}
       ,{2, 2, 12}
    }));
    REQUIRE( formula(x, y) == z);
}

cmake_minimum_required(VERSION 3.9)
project(Catch2_testing)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)

# ============= Conan Bootstrap =============================#

# Download automatically, you can also just copy the conan.cmake file
if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
   message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
   file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.13/conan.cmake"
                 "${CMAKE_BINARY_DIR}/conan.cmake")
endif()

include(${CMAKE_BINARY_DIR}/conan.cmake)

conan_cmake_run(REQUIRES
                Catch2/2.7.2@catchorg/stable
                BASIC_SETUP
                BUILD missing
                )
#============= Find Packages ================================#

find_package(Catch2 REQUIRED)

#---------------------------------------------------#
#             Targets Settings                      #
#---------------------------------------------------#

add_executable(testcatch2 testcatch2.cpp test-main.cpp)
target_link_libraries(testcatch2)

$ ./testcatch2 -h

Catch v2.7.2
usage:
  testcatch2 [<test name|pattern|tags> ... ] options

where options are:
  -?, -h, --help                            display usage information
  -l, --list-tests                          list all/matching test cases
  -t, --list-tags                           list all/matching tags
  -s, --success                             include successful tests in
                                            output
  -b, --break                               break into debugger on failure
  -e, --nothrow                             skip exception tests
  -i, --invisibles                          show invisibles (tabs, newlines)
  -o, --out <filename>                      output filename
  -r, --reporter <name>                     reporter to use (defaults to
                                            console)
  -n, --name <name>                         suite name
  -a, --abort                               abort at first failure
  -x, --abortx <no. failures>               abort after x failures
  -w, --warn <warning name>                 enable warnings
  -d, --durations <yes|no>                  show test durations
  -f, --input-file <filename>               load test names to run from a
                                            file
  -#, --filenames-as-tags                   adds a tag for the filename
  -c, --section <section name>              specify section to run
  -v, --verbosity <quiet|normal|high>       set output verbosity
  --list-test-names-only                    list all/matching test cases
                                            names only
  --list-reporters                          list all reporters
  --order <decl|lex|rand>                   test case order (defaults to
                                            decl)
  --rng-seed <'time'|number>                set a specific seed for random
                                            numbers
  --use-colour <yes|no>                     should output be colourised
  --libidentify                             report name and version according
                                            to libidentify standard
  --wait-for-keypress <start|exit|both>     waits for a keypress before
                                            exiting
  --benchmark-resolution-multiple           multiple of clock resolution to
  <multiplier>                              run benchmarks

For more detailed usage please see the project docs

$ ./testcatch2 --list-tests
All available test cases:
  Test function furmula A
      [tag1]
  Test function formula B
      [tag2]
  Testing with struct
  Testing with structured bindings
4 test cases

$ ./testcatch2

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
testcatch2 is a Catch v2.7.2 host application.
Run with -? for options

-------------------------------------------------------------------------------
Test function formula B
-------------------------------------------------------------------------------
/home/archbox/Documents/projects/fquant/testcatch2.cpp:17
...............................................................................

/home/archbox/Documents/projects/fquant/testcatch2.cpp:21: FAILED:
  REQUIRE( formula(2, 5) == 10 )
with expansion:
  18 == 10

-------------------------------------------------------------------------------
Testing with struct
-------------------------------------------------------------------------------
/home/archbox/Documents/projects/fquant/testcatch2.cpp:31
...............................................................................

/home/archbox/Documents/projects/fquant/testcatch2.cpp:41: FAILED:
  REQUIRE( formula(t.x, t.y) == t.expected )
with expansion:
  4 == 6

===============================================================================
test cases:  4 |  2 passed | 2 failed
assertions: 13 | 11 passed | 2 failed

#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include <doctest.h>

int formula(int x, int y)
{
    return 4 * x + 2 * y;
}

TEST_CASE("Test function furmula A")
{
    CHECK( formula(3, 4) == 20 );
    CHECK( formula(4, 5) == 26 );
    CHECK( formula(4, 5) < 100 );
    CHECK( formula(4, 5) != 0 );
}

TEST_CASE("Test function formula B")
{
    CHECK( formula(0, 0) == 0  );
    // Intentionally fails
    CHECK( formula(2, 5) == 10 );
}

cmake_minimum_required(VERSION 3.9)
project( doctest_experiment
         VERSION      0.1
         DESCRIPTION  "A doctest experiment"
        )
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_VERBOSE_MAKEFILE ON)

# ============= Conan Bootstrap =============================#

# Download automatically, you can also just copy the conan.cmake file
if(NOT EXISTS "${CMAKE_BINARY_DIR}/conan.cmake")
   message(STATUS "Downloading conan.cmake from https://github.com/conan-io/cmake-conan")
   file(DOWNLOAD "https://github.com/conan-io/cmake-conan/raw/v0.13/conan.cmake"
                 "${CMAKE_BINARY_DIR}/conan.cmake")
endif()

include(${CMAKE_BINARY_DIR}/conan.cmake)

conan_cmake_run(REQUIRES
                doctest/2.3.1@bincrafters/stable
                BASIC_SETUP
                BUILD missing
                )

#============= Find Packages ================================#

find_package(doctest 2.3.1 REQUIRED)

#---------------------------------------------------#
#             Targets Settings                      #
#---------------------------------------------------#

add_executable(doctest_experiment doctest_experiment.cpp)
copy_after_build(doctest_experiment)
# target_link_libraries(doctest_experiment doctest::doctest)

$ bin/doctest_experiment -h
[doctest] doctest version is "2.3.1"
[doctest]
[doctest] boolean values: "1/on/yes/true" or "0/off/no/false"
[doctest] filter  values: "str1,str2,str3" (comma separated strings)
[doctest]
[doctest] filters use wildcards for matching strings
[doctest] something passes a filter if any of the strings in a filter matches
[doctest]
[doctest] ALL FLAGS, OPTIONS AND FILTERS ALSO AVAILABLE WITH A "dt-" PREFIX!!!
[doctest]
[doctest] Query flags - the program quits after them. Available:

 -?,   --help, -h                      prints this message
 -v,   --version                       prints the version
 -c,   --count                         prints the number of matching tests
 -ltc, --list-test-cases               lists all matching tests by name
 -lts, --list-test-suites              lists all matching test suites
 -lr,  --list-reporters                lists all registered reporters

[doctest] The available <int>/<string> options/filters are:

 -tc,  --test-case=<filters>           filters     tests by their name
 -tce, --test-case-exclude=<filters>   filters OUT tests by their name
 -sf,  --source-file=<filters>         filters     tests by their file
 -sfe, --source-file-exclude=<filters> filters OUT tests by their file
 -ts,  --test-suite=<filters>          filters     tests by their test suite
 -tse, --test-suite-exclude=<filters>  filters OUT tests by their test suite
 -sc,  --subcase=<filters>             filters     subcases by their name
 -sce, --subcase-exclude=<filters>     filters OUT subcases by their name
 -r,   --reporters=<filters>           reporters to use (console is default)
 -o,   --out=<string>                  output filename
 -ob,  --order-by=<string>             how the tests should be ordered
                                       <string> - by [file/suite/name/rand]
 -rs,  --rand-seed=<int>               seed for random ordering
 -f,   --first=<int>                   the first test passing the filters to
                                       execute - for range-based execution
 -l,   --last=<int>                    the last test passing the filters to
                                       execute - for range-based execution
 -aa,  --abort-after=<int>             stop after <int> failed assertions
 -scfl,--subcase-filter-levels=<int>   apply filters for the first <int> levels

[doctest] Bool options - can be used like flags and true is assumed. Available:

 -s,   --success=<bool>                include successful assertions in output
 -cs,  --case-sensitive=<bool>         filters being treated as case sensitive
 -e,   --exit=<bool>                   exits after the tests finish
 -d,   --duration=<bool>               prints the time duration of each test
 -nt,  --no-throw=<bool>               skips exceptions-related assert checks
 -ne,  --no-exitcode=<bool>            returns (or exits) always with success
 -nr,  --no-run=<bool>                 skips all runtime doctest operations
 -nv,  --no-version=<bool>             omit the framework version in the output
 -nc,  --no-colors=<bool>              disables colors in output
 -fc,  --force-colors=<bool>           use colors even when not in a tty
 -nb,  --no-breaks=<bool>              disables breakpoints in debuggers
 -ns,  --no-skip=<bool>                don't skip test cases marked as skip
 -gfl, --gnu-file-line=<bool>          :n: vs (n): for line numbers in output
 -npf, --no-path-filenames=<bool>      only filenames and no paths in output
 -nln, --no-line-numbers=<bool>        0 instead of real line numbers in output

[doctest] for more information visit the project documentation

$ bin/doctest_experiment --list-test-cases
[doctest] listing all test case names
===============================================================================
Test function furmula A
Test function formula B
================================================

$ bin/doctest_experiment
[doctest] doctest version is "2.3.1"
[doctest] run with "--help" for options
===============================================================================
/home/archbox/Documents/projects/fquant/doctest_experiment.cpp:21:
TEST CASE:  Test function formula B

/home/archbox/Documents/projects/fquant/doctest_experiment.cpp:25: ERROR: CHECK( formula(2, 5) == 10 ) is NOT correct!
  values: CHECK( 18 == 10 )

===============================================================================
[doctest] test cases:      2 |      1 passed |      1 failed |      0 skipped
[doctest] assertions:      6 |      5 passed |      1 failed |
[doctest] Status: FAILURE!