JSONUtils.hpp

Go to the documentation of this file.

/*
    Copyright (C) 2014-2016 Leosac
 
    This file is part of Leosac.
 
    Leosac is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    Leosac is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU Affero General Public License for more details.
 
    You should have received a copy of the GNU Affero General Public License
    along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
 
#pragma once
 
#include "core/auth/AuthFwd.hpp"
#include "exception/leosacexception.hpp"
#include "tools/Uuid.hpp"
#include <boost/lexical_cast.hpp>
#include <chrono>
#include <nlohmann/json.hpp>
#include <type_traits>
 
 
namespace nlohmann
{
 
template <>
struct adl_serializer<Leosac::UUID>
{
    static void to_json(json &j, const Leosac::UUID &uuid)
    {
        if (uuid.is_nil())
        {
            j = nullptr;
        }
        else
        {
            j = uuid.to_string();
        }
    }
 
    static void from_json(const json &j, Leosac::UUID &uuid)
    {
        if (j.is_null())
        {
            uuid = Leosac::UUID::null_uuid();
        }
        else
        {
            if (j.is_string())
            {
                std::string str = j.get<std::string>();
                uuid = Leosac::UUID(boost::lexical_cast<boost::uuids::uuid>(str));
            }
            else if (j.is_number_unsigned() && j.get<uint64_t>() == 0)
            {
                uuid = Leosac::UUID::null_uuid();
            }
            else
            {
                throw LEOSACException("Failed to unserialize UUID");
            }
        }
    }
};
}
 
namespace Leosac
{
 
using json = nlohmann::json;
 
namespace JSONUtil
{
template <typename T>
typename std::enable_if<!std::is_same<const char *, T>::value &&
                            !std::is_same<std::chrono::system_clock::time_point,
                                          std::remove_reference_t<T>>::value &&
                            !std::is_enum<T>::value,
                        T>::type
extract_with_default(const nlohmann::json &obj, const std::string &key,
                     T default_value)
{
    T ret = default_value;
    try
    {
        if (!obj.at(key).is_null())
            ret = obj.at(key).get<T>();
    }
    catch (const json::out_of_range &e)
    {
    }
    return ret;
}
 
template <typename T>
typename std::enable_if<std::is_enum<T>::value, T>::type
extract_with_default(const nlohmann::json &obj, const std::string &key,
                     T default_value)
{
    T ret = default_value;
    try
    {
        if (!obj.at(key).is_null())
        {
            // Extract using enum's underlying type, then case back.
            ret = static_cast<T>(obj.at(key).get<std::underlying_type_t<T>>());
        }
    }
    catch (const json::out_of_range &e)
    {
    }
    return ret;
}
 
template <typename T>
typename std::enable_if<std::is_same<const char *, T>::value, std::string>::type
extract_with_default(const nlohmann::json &obj, const std::string &key,
                     T default_value)
{
    return extract_with_default<std::string>(obj, key, default_value);
}
 
std::chrono::system_clock::time_point
extract_with_default(const nlohmann::json &obj, const std::string &key,
                     const std::chrono::system_clock::time_point &tp);
 
Auth::ValidityInfo extract_validity_with_default(const nlohmann::json &obj,
                                                 const std::string &base_key,
                                                 const Auth::ValidityInfo &def);
}
}