Changed everything to use Boost

Author: marcelweikum

exercises/practice/baffling-birthdays/.meta/example.cpp

@@ -1,46 +1,33 @@
-#include <chrono>
 #include <random>
+#include <unordered_set>
 
 #include "baffling_birthdays.h"
 
 namespace baffling_birthdays {
 
 Date parse_date(const std::string& iso) {
-    Date d{0, 0, 0};
-    if (iso.size() < 10) return d;
     try {
-        d.year = std::stoi(iso.substr(0, 4));
-        d.month = std::stoi(iso.substr(5, 2));
-        d.day = std::stoi(iso.substr(8, 2));
+        return boost::gregorian::from_simple_string(iso);
     } catch (...) {
-        d = {0, 0, 0};
+        return Date(boost::gregorian::not_a_date_time);
     }
-    return d;
-}
-
-std::string to_string(const Date& d) {
-    std::ostringstream oss;
-    oss << std::setw(4) << std::setfill('0') << d.year << '-' << std::setw(2)
-        << std::setfill('0') << d.month << '-' << std::setw(2)
-        << std::setfill('0') << d.day;
-    return oss.str();
 }
 
 bool shared_birthday(const std::vector<Date>& dates) {
-    std::unordered_set<int> seen_md;
+    std::unordered_set<unsigned> seen_md;
     seen_md.reserve(dates.size());
     for (auto const& d : dates) {
-        if (d.month < 1 || d.month > 12 || d.day < 1 || d.day > 31) continue;
-        int key = d.month * 100 + d.day;
+        if (d.is_not_a_date()) continue;
+        unsigned key = d.month().as_number() * 100 + d.day();
         if (seen_md.count(key)) return true;
         seen_md.insert(key);
     }
     return false;
 }
 
-std::vector<Date> random_birthdates_dates(std::size_t group_size) {
+std::vector<Date> random_birthdates(std::size_t group_size) {
     static std::mt19937_64 gen(
-        std::chrono::system_clock::now().time_since_epoch().count());
+        static_cast<unsigned long>(std::random_device{}()));
     std::uniform_int_distribution<int> month_dist(1, 12);
     const int days_in_month[12] = {31, 28, 31, 30, 31, 30,
                                    31, 31, 30, 31, 30, 31};
@@ -49,7 +36,8 @@ std::vector<Date> random_birthdates_dates(std::size_t group_size) {
     for (std::size_t i = 0; i < group_size; ++i) {
         int m = month_dist(gen);
         std::uniform_int_distribution<int> day_dist(1, days_in_month[m - 1]);
-        dates.push_back(Date{2001, m, day_dist(gen)});
+        int d = day_dist(gen);
+        dates.push_back(Date(2001, m, d));
     }
     return dates;
 }

exercises/practice/baffling-birthdays/.meta/example.h

@@ -1,25 +1,17 @@
 #pragma once
 
-#include <iomanip>
-#include <sstream>
+#include <boost/date_time/gregorian/gregorian.hpp>
 #include <string>
-#include <unordered_set>
 #include <vector>
 
 namespace baffling_birthdays {
 
-struct Date {
-    int year;
-    int month;
-    int day;
-};
+using Date = boost::gregorian::date;
 
 Date parse_date(const std::string& iso);
 
-std::string to_string(const Date& d);
-
 bool shared_birthday(const std::vector<Date>& dates);
-std::vector<Date> random_birthdates_dates(std::size_t group_size);
+std::vector<Date> random_birthdates(std::size_t group_size);
 
 double estimated_probability_of_shared_birthday(std::size_t group_size);
 
@@ -32,11 +24,12 @@ inline bool shared_birthday(const std::vector<std::string>& birthdates) {
     return shared_birthday(dates);
 }
 
-inline std::vector<std::string> random_birthdates(std::size_t group_size) {
-    auto dates = random_birthdates_dates(group_size);
+inline std::vector<std::string> random_birthdates_str(std::size_t group_size) {
+    auto dates = random_birthdates(group_size);
     std::vector<std::string> out;
     out.reserve(group_size);
-    for (auto const& d : dates) out.push_back(to_string(d));
+    for (auto const& d : dates)
+        out.push_back(boost::gregorian::to_iso_extended_string(d));
     return out;
 }
 

exercises/practice/baffling-birthdays/CMakeLists.txt

@@ -7,6 +7,11 @@ cmake_minimum_required(VERSION 3.5.1)
 # Name the project after the exercise
 project(${exercise} CXX)
 
+# Locate Boost date_time library
+set(Boost_USE_MULTITHREADED ON)
+set(Boost_USE_STATIC_RUNTIME OFF)
+find_package(Boost 1.58 REQUIRED COMPONENTS date_time)
+
 # Get a source filename from the exercise name by replacing -'s with _'s
 string(REPLACE "-" "_" file ${exercise})
 
@@ -49,6 +54,12 @@ if("${CMAKE_CXX_COMPILER_ID}" MATCHES "(GNU|Clang)")
     )
 endif()
 
+# We need boost libraries
+target_link_libraries(${exercise}
+    PRIVATE
+    Boost::date_time
+)
+
 # Configure to run all the tests?
 if(${EXERCISM_RUN_ALL_TESTS})
     target_compile_definitions(${exercise} PRIVATE EXERCISM_RUN_ALL_TESTS)

exercises/practice/baffling-birthdays/baffling_birthdays_test.cpp

@@ -1,117 +1,122 @@
 #include "baffling_birthdays.h"
+
+#include <boost/date_time/gregorian/gregorian.hpp>
 #ifdef EXERCISM_TEST_SUITE
 #include <catch2/catch.hpp>
 #else
 #include "test/catch.hpp"
 #endif
 
+using namespace baffling_birthdays;
+using boost::gregorian::date;
+
 TEST_CASE("one_birthdate", "[716dcc2b-8fe4-4fc9-8c48-cbe70d8e6b67]") {
-    std::vector<std::string> birthdates{"2000-01-01"};
-    REQUIRE_FALSE(baffling_birthdays::shared_birthday(birthdates));
+    std::vector<date> dates{date(2000, 1, 1)};
+    REQUIRE_FALSE(shared_birthday(dates));
 }
 
 #if defined(EXERCISM_RUN_ALL_TESTS)
 
 TEST_CASE("two_birthdates_with_same_year_month_and_day",
-          "[f7b3eb26-bcfc-4a1e-a2de-af07afc33f45]") {
-    std::vector<std::string> birthdates{"2000-01-01", "2000-01-01"};
-    REQUIRE(baffling_birthdays::shared_birthday(birthdates));
+          "[f7b3eb26-bcfc-4e1e-a2de-af07afc33f45]") {
+    std::vector<date> dates{date(2000, 1, 1), date(2000, 1, 1)};
+    REQUIRE(shared_birthday(dates));
 }
 
 TEST_CASE("two_birthdates_with_same_year_and_month_but_different_day",
           "[7193409a-6e16-4bcb-b4cc-9ffe55f79b25]") {
-    std::vector<std::string> birthdates{"2012-05-09", "2012-05-17"};
-    REQUIRE_FALSE(baffling_birthdays::shared_birthday(birthdates));
+    std::vector<date> dates{date(2012, 5, 9), date(2012, 5, 17)};
+    REQUIRE_FALSE(shared_birthday(dates));
 }
 
 TEST_CASE("two_birthdates_with_same_month_and_day_but_different_year",
           "[d04db648-121b-4b72-93e8-d7d2dced4495]") {
-    std::vector<std::string> birthdates{"1999-10-23", "1988-10-23"};
-    REQUIRE(baffling_birthdays::shared_birthday(birthdates));
+    std::vector<date> dates{date(1999, 10, 23), date(1988, 10, 23)};
+    REQUIRE(shared_birthday(dates));
 }
 
 TEST_CASE("two_birthdates_with_same_year_but_different_month_and_day",
           "[3c8bd0f0-14c6-4d4c-975a-4c636bfdc233]") {
-    std::vector<std::string> birthdates{"2007-12-19", "2007-04-27"};
-    REQUIRE_FALSE(baffling_birthdays::shared_birthday(birthdates));
+    std::vector<date> dates{date(2007, 12, 19), date(2007, 4, 27)};
+    REQUIRE_FALSE(shared_birthday(dates));
 }
 
 TEST_CASE("two_birthdates_with_different_year_month_and_day",
           "[df5daba6-0879-4480-883c-e855c99cdaa3]") {
-    std::vector<std::string> birthdates{"1997-08-04", "1963-11-23"};
-    REQUIRE_FALSE(baffling_birthdays::shared_birthday(birthdates));
+    std::vector<date> dates{date(1997, 8, 4), date(1963, 11, 23)};
+    REQUIRE_FALSE(shared_birthday(dates));
 }
 
 TEST_CASE("multiple_birthdates_without_shared_birthday",
           "[0c17b220-cbb9-4bd7-872f-373044c7b406]") {
-    std::vector<std::string> birthdates{"1966-07-29", "1977-02-12",
-                                        "2001-12-25", "1980-11-10"};
-    REQUIRE_FALSE(baffling_birthdays::shared_birthday(birthdates));
+    std::vector<date> dates{date(1966, 7, 29), date(1977, 2, 12),
+                            date(2001, 12, 25), date(1980, 11, 10)};
+    REQUIRE_FALSE(shared_birthday(dates));
 }
 
 TEST_CASE("multiple_birthdates_with_one_shared_birthday",
           "[966d6b0b-5c0a-4b8c-bc2d-64939ada49f8]") {
-    std::vector<std::string> birthdates{"1966-07-29", "1977-02-12",
-                                        "2001-07-29", "1980-11-10"};
-    REQUIRE(baffling_birthdays::shared_birthday(birthdates));
+    std::vector<date> dates{date(1966, 7, 29), date(1977, 2, 12),
+                            date(2001, 7, 29), date(1980, 11, 10)};
+    REQUIRE(shared_birthday(dates));
 }
 
 TEST_CASE("multiple_birthdates_with_more_than_one_shared_birthday",
           "[b7937d28-403b-4500-acce-4d9fe3a9620d]") {
-    std::vector<std::string> birthdates{
-        "1966-07-29", "1977-02-12", "2001-12-25", "1980-07-29", "2019-02-12"};
-    REQUIRE(baffling_birthdays::shared_birthday(birthdates));
+    std::vector<date> dates{date(1966, 7, 29), date(1977, 2, 12),
+                            date(2001, 12, 25), date(1980, 7, 29),
+                            date(2019, 2, 12)};
+    REQUIRE(shared_birthday(dates));
 }
 
 TEST_CASE("generate_requested_number_of_birthdates",
           "[70b38cea-d234-4697-b146-7d130cd4ee12]") {
     const std::size_t group_size = 10;
-    auto dates = baffling_birthdays::random_birthdates(group_size);
-    REQUIRE(dates.size() == group_size);
+    auto d_dates = random_birthdates(group_size);
+    REQUIRE(d_dates.size() == group_size);
 }
 
 TEST_CASE("years_are_not_leap_years",
           "[d9d5b7d3-5fea-4752-b9c1-3fcd176d1b03]") {
     const std::size_t group_size = 1000;
-    auto dates = baffling_birthdays::random_birthdates(group_size);
-    for (auto const& date : dates) {
-        REQUIRE(!(date.substr(5, 2) == "02" && date.substr(8, 2) == "29"));
+    auto d_dates = random_birthdates(group_size);
+    for (auto const& d : d_dates) {
+        REQUIRE(!(d.month().as_number() == 2 && d.day() == 29));
     }
 }
 
 TEST_CASE("months_are_random", "[d1074327-f68c-4c8a-b0ff-e3730d0f0521]") {
     const std::size_t group_size = 1000;
-    auto d1 = baffling_birthdays::random_birthdates(group_size);
-    auto d2 = baffling_birthdays::random_birthdates(group_size);
+    auto d1 = random_birthdates(group_size);
+    auto d2 = random_birthdates(group_size);
     REQUIRE(d1 != d2);
 }
 
 TEST_CASE("days_are_random", "[7df706b3-c3f5-471d-9563-23a4d0577940]") {
     const std::size_t group_size = 1000;
-    auto d1 = baffling_birthdays::random_birthdates(group_size);
-    auto d2 = baffling_birthdays::random_birthdates(group_size);
+    auto d1 = random_birthdates(group_size);
+    auto d2 = random_birthdates(group_size);
     REQUIRE(d1 != d2);
 }
 
 TEST_CASE("for_one_person", "[89a462a4-4265-4912-9506-fb027913f221]") {
-    REQUIRE(baffling_birthdays::estimated_probability_of_shared_birthday(1) ==
-            Approx(0.0));
+    REQUIRE(estimated_probability_of_shared_birthday(1) == Approx(0.0));
 }
 
 TEST_CASE("among_ten_people", "[ec31c787-0ebb-4548-970c-5dcb4eadfb5f]") {
-    REQUIRE(baffling_birthdays::estimated_probability_of_shared_birthday(10) ==
+    REQUIRE(estimated_probability_of_shared_birthday(10) ==
             Approx(11.694818).epsilon(0.01));
 }
 
 TEST_CASE("among_twenty-three_people",
           "[b548afac-a451-46a3-9bb0-cb1f60c48e2f]") {
-    REQUIRE(baffling_birthdays::estimated_probability_of_shared_birthday(23) ==
+    REQUIRE(estimated_probability_of_shared_birthday(23) ==
             Approx(50.729723).epsilon(0.01));
 }
 
 TEST_CASE("among_seventy_people", "[e43e6b9d-d77b-4f6c-a960-0fc0129a0bc5]") {
-    REQUIRE(baffling_birthdays::estimated_probability_of_shared_birthday(70) ==
+    REQUIRE(estimated_probability_of_shared_birthday(70) ==
             Approx(99.915958).epsilon(0.01));
 }
 
-#endif
+#endif