JSON to C++ Converter

{
  "id": "ord_9F2KX",
  "status": "processing",
  "paid": true,
  "customer": { "name": "Ada Lovelace", "email": "ada@example.com", "phone": null },
  "items": [
    { "sku": "KB-75", "qty": 1, "price": 149.99 },
    { "sku": "MS-12", "qty": 2, "price": 39.5 }
  ],
  "total": 228.99
}

//  To parse this JSON data, first install
//
//      Boost     http://www.boost.org
//      json.hpp  https://github.com/nlohmann/json
//
//  Then include this file, and then do
//
//     Root data = nlohmann::json::parse(jsonString);

#pragma once

#include "json.hpp"

#include <boost/optional.hpp>
#include <stdexcept>
#include <regex>

namespace quicktype {
    using nlohmann::json;

    #ifndef NLOHMANN_UNTYPED_quicktype_HELPER
    #define NLOHMANN_UNTYPED_quicktype_HELPER
    inline json get_untyped(const json & j, const char * property) {
        if (j.find(property) != j.end()) {
            return j.at(property).get<json>();
        }
        return json();
    }

    inline json get_untyped(const json & j, std::string property) {
        return get_untyped(j, property.data());
    }
    #endif

    class Customer {
        public:
        Customer() = default;
        virtual ~Customer() = default;

        private:
        std::string name;
        std::string email;
        nlohmann::json phone;

        public:
        const std::string & get_name() const { return name; }
        std::string & get_mutable_name() { return name; }
        void set_name(const std::string & value) { this->name = value; }

        const std::string & get_email() const { return email; }
        std::string & get_mutable_email() { return email; }
        void set_email(const std::string & value) { this->email = value; }

        const nlohmann::json & get_phone() const { return phone; }
        nlohmann::json & get_mutable_phone() { return phone; }
        void set_phone(const nlohmann::json & value) { this->phone = value; }
    };

    class Item {
        public:
        Item() = default;
        virtual ~Item() = default;

        private:
        std::string sku;
        int64_t qty;
        double price;

        public:
        const std::string & get_sku() const { return sku; }
        std::string & get_mutable_sku() { return sku; }
        void set_sku(const std::string & value) { this->sku = value; }

        const int64_t & get_qty() const { return qty; }
        int64_t & get_mutable_qty() { return qty; }
        void set_qty(const int64_t & value) { this->qty = value; }

        const double & get_price() const { return price; }
        double & get_mutable_price() { return price; }
        void set_price(const double & value) { this->price = value; }
    };

    class Root {
        public:
        Root() = default;
        virtual ~Root() = default;

        private:
        std::string id;
        std::string status;
        bool paid;
        Customer customer;
        std::vector<Item> items;
        double total;

        public:
        const std::string & get_id() const { return id; }
        std::string & get_mutable_id() { return id; }
        void set_id(const std::string & value) { this->id = value; }

        const std::string & get_status() const { return status; }
        std::string & get_mutable_status() { return status; }
        void set_status(const std::string & value) { this->status = value; }

        const bool & get_paid() const { return paid; }
        bool & get_mutable_paid() { return paid; }
        void set_paid(const bool & value) { this->paid = value; }

        const Customer & get_customer() const { return customer; }
        Customer & get_mutable_customer() { return customer; }
        void set_customer(const Customer & value) { this->customer = value; }

        const std::vector<Item> & get_items() const { return items; }
        std::vector<Item> & get_mutable_items() { return items; }
        void set_items(const std::vector<Item> & value) { this->items = value; }

        const double & get_total() const { return total; }
        double & get_mutable_total() { return total; }
        void set_total(const double & value) { this->total = value; }
    };
}

namespace quicktype {
    void from_json(const json & j, Customer & x);
    void to_json(json & j, const Customer & x);

    void from_json(const json & j, Item & x);
    void to_json(json & j, const Item & x);

    void from_json(const json & j, Root & x);
    void to_json(json & j, const Root & x);

    inline void from_json(const json & j, Customer& x) {
        x.set_name(j.at("name").get<std::string>());
        x.set_email(j.at("email").get<std::string>());
        x.set_phone(get_untyped(j, "phone"));
    }

    inline void to_json(json & j, const Customer & x) {
        j = json::object();
        j["name"] = x.get_name();
        j["email"] = x.get_email();
        j["phone"] = x.get_phone();
    }

    inline void from_json(const json & j, Item& x) {
        x.set_sku(j.at("sku").get<std::string>());
        x.set_qty(j.at("qty").get<int64_t>());
        x.set_price(j.at("price").get<double>());
    }

    inline void to_json(json & j, const Item & x) {
        j = json::object();
        j["sku"] = x.get_sku();
        j["qty"] = x.get_qty();
        j["price"] = x.get_price();
    }

    inline void from_json(const json & j, Root& x) {
        x.set_id(j.at("id").get<std::string>());
        x.set_status(j.at("status").get<std::string>());
        x.set_paid(j.at("paid").get<bool>());
        x.set_customer(j.at("customer").get<Customer>());
        x.set_items(j.at("items").get<std::vector<Item>>());
        x.set_total(j.at("total").get<double>());
    }

    inline void to_json(json & j, const Root & x) {
        j = json::object();
        j["id"] = x.get_id();
        j["status"] = x.get_status();
        j["paid"] = x.get_paid();
        j["customer"] = x.get_customer();
        j["items"] = x.get_items();
        j["total"] = x.get_total();
    }
}