yaml.hpp

Go to the documentation of this file.

 
/*
  Copyright (c) 2017, Matt Continisio
  All rights reserved.
 
  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of ser20 nor the
        names of its contributors may be used to endorse or promote products
        derived from this software without specific prior written permission.
 
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  DISCLAIMED. IN NO EVENT SHALL RANDOLPH VOORHIES OR SHANE GRANT BE LIABLE FOR ANY
  DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef SER20_ARCHIVES_YAML_HPP_
#define SER20_ARCHIVES_YAML_HPP_
 
#include <ser20/details/util.hpp>
#include <ser20/external/base64.hpp>
#include <ser20/ser20.hpp>
 
#include <yaml-cpp/yaml.h>
 
#include <cstring>
#include <limits>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
 
namespace ser20
{
 
class YAMLOutputArchive
    : public OutputArchive<YAMLOutputArchive>
    , public traits::TextArchive
{
    enum class NodeType
    {
        StartObject,
        InObject,
        StartArray,
        InArray
    };
 
public:
    static inline constexpr bool is_binary = false;
 
    YAMLOutputArchive(std::ostream& stream) : OutputArchive<YAMLOutputArchive>(this), out(stream), nextName(nullptr)
    {
        nameCounter.push(0);
        nodeStack.push(NodeType::StartObject);
    }
 
    ~YAMLOutputArchive() noexcept
    {
        if(nodeStack.top() == NodeType::InObject)
        {
            emitter << YAML::EndMap;
        }
        else if(nodeStack.top() == NodeType::InArray)
        {
            emitter << YAML::EndSeq;
        }
 
        out << emitter.c_str();
    }
 
 
    void saveBinaryValue(const void* data, size_t size, const char* name = nullptr)
    {
        setNextName(name);
        writeName();
 
        auto base64string = base64::encode(reinterpret_cast<const unsigned char*>(data), size);
        saveValue(base64string);
    };
 
 
 
 
    void startNode()
    {
        writeName();
        nodeStack.push(NodeType::StartObject);
        nameCounter.push(0);
    }
 
    void finishNode()
    {
        // if we ended up serializing an empty object or array, writeName
        // will never have been called - so start and then immediately end
        // the object/array.
        //
        // We'll also end any object/arrays we happen to be in
        switch(nodeStack.top())
        {
            case NodeType::StartArray:
                emitter << YAML::BeginSeq;
            case NodeType::InArray:
                emitter << YAML::EndSeq;
                break;
            case NodeType::StartObject:
                emitter << YAML::BeginMap;
            case NodeType::InObject:
                emitter << YAML::EndMap;
                break;
        }
 
        nodeStack.pop();
        nameCounter.pop();
    }
 
    void setNextName(const char* name)
    {
        nextName = name;
    }
 
    void saveValue(bool b)
    {
        emitter << b;
    }
    void saveValue(int i)
    {
        emitter << i;
    }
    void saveValue(unsigned u)
    {
        emitter << u;
    }
    void saveValue(int64_t i64)
    {
        emitter << i64;
    }
    void saveValue(uint64_t u64)
    {
        emitter << u64;
    }
    void saveValue(double d)
    {
        emitter << d;
    }
    void saveValue(std::string const& s)
    {
        emitter << s;
    }
    void saveValue(char const* s)
    {
        emitter << s;
    }
    void saveValue(std::nullptr_t)
    {
        emitter << nullptr;
    }
 
private:
    // Some compilers/OS have difficulty disambiguating the above for various flavors of longs, so we provide
    // special overloads to handle these cases.
 
    template<class T>
    inline void saveLong(T l)
        requires(sizeof(T) == sizeof(std::int32_t) && std::is_signed_v<T>)
    {
        saveValue(static_cast<std::int32_t>(l));
    }
 
    template<class T>
    inline void saveLong(T l)
        requires(sizeof(T) != sizeof(std::int32_t) && std::is_signed_v<T>)
    {
        saveValue(static_cast<std::int64_t>(l));
    }
 
    template<class T>
    inline void saveLong(T lu)
        requires(sizeof(T) == sizeof(std::int32_t) && std::is_unsigned_v<T>)
    {
        saveValue(static_cast<std::uint32_t>(lu));
    }
 
    template<class T>
    inline void saveLong(T lu)
        requires(sizeof(T) != sizeof(std::int32_t) && std::is_unsigned_v<T>)
    {
        saveValue(static_cast<std::uint64_t>(lu));
    }
 
public:
#if defined(_MSC_VER) && _MSC_VER < 1916
    void saveValue(unsigned long lu)
    {
        saveLong(lu);
    };
#else  // _MSC_VER
    template<class T>
    inline void saveValue(T t)
        requires(std::is_same_v<T, long> && !std::is_same_v<T, int> && !std::is_same_v<T, std::int64_t>)
    {
        saveLong(t);
    }
 
    template<class T>
    inline void saveValue(T t)
        requires(std::is_same_v<T, unsigned long> && !std::is_same_v<T, unsigned> && !std::is_same_v<T, std::uint64_t>)
    {
        saveLong(t);
    }
#endif // _MSC_VER
 
 
    template<class T>
    inline void saveValue(T const& t)
        requires(std::is_arithmetic_v<T> && !std::is_same_v<T, long> && !std::is_same_v<T, unsigned long> &&
                 !std::is_same_v<T, std::int64_t> && !std::is_same_v<T, std::uint64_t> &&
                 !std::is_same_v<T, long long> && !std::is_same_v<T, unsigned long long> &&
                 (sizeof(T) >= sizeof(long double) || sizeof(T) >= sizeof(long long)))
    {
        std::stringstream ss;
        ss.precision(std::numeric_limits<long double>::max_digits10);
        ss << t;
        saveValue(ss.str());
    }
 
 
    void writeName()
    {
        NodeType& nodeType = nodeStack.top();
 
        // Start up either an object or an array, depending on state
        if(nodeType == NodeType::StartArray)
        {
            emitter << YAML::BeginSeq;
            nodeType = NodeType::InArray;
        }
        else if(nodeType == NodeType::StartObject)
        {
            emitter << YAML::BeginMap;
            nodeType = NodeType::InObject;
        }
 
        // Array types do not output names
        if(nodeType == NodeType::InArray)
        {
            return;
        }
 
        emitter << YAML::Key;
 
        if(nextName == nullptr)
        {
            std::string name = "value" + std::to_string(nameCounter.top()++) + "\0";
            saveValue(name);
        }
        else
        {
            saveValue(nextName);
            nextName = nullptr;
        }
 
        emitter << YAML::Value;
    }
 
    void makeArray()
    {
        nodeStack.top() = NodeType::StartArray;
    }
 
 
private:
    std::ostream& out;
    YAML::Emitter emitter;
    char const* nextName;             
    std::stack<uint32_t> nameCounter; 
    std::stack<NodeType> nodeStack;
 
}; // YAMLOutputArchive
 
class YAMLInputArchive
    : public InputArchive<YAMLInputArchive>
    , public traits::TextArchive
{
    typedef YAML::const_iterator YAMLIterator;
 
public:
    YAMLInputArchive(std::istream& stream)
        : InputArchive<YAMLInputArchive>(this)
        , itsNextName(nullptr)
        , itsDocument(YAML::Load(stream))
    {
        if(itsDocument.IsSequence())
        {
            itsIteratorStack.emplace_back(itsDocument.begin(), itsDocument.end(), Iterator::Type::Value);
        }
 
        else
        {
            itsIteratorStack.emplace_back(itsDocument.begin(), itsDocument.end(), Iterator::Type::Member);
        }
    }
 
    ~YAMLInputArchive() noexcept = default;
 
 
    void loadBinaryValue(void* data, size_t size, const char* name = nullptr)
    {
        itsNextName = name;
 
        std::string encoded;
        loadValue(encoded);
        auto decoded = base64::decode(encoded);
 
        if(size != decoded.size())
        {
            throw Exception("Decoded binary data size does not match specified size");
        }
 
        std::memcpy(data, decoded.data(), decoded.size());
        itsNextName = nullptr;
    };
 
private:
 
 
    class Iterator
    {
    public:
        enum Type
        {
            Value,
            Member,
            Null_
        };
 
        Iterator() : itsType(Null_)
        {
        }
 
        Iterator(YAMLIterator begin, YAMLIterator end, Type type)
            : itsItBegin(begin)
            , itsItEnd(end)
            , itsItCurrent(begin)
            , itsType(type)
        {
            if(std::distance(begin, end) == 0)
            {
                itsType = Null_;
            }
 
            if(itsType == Member && itsItCurrent != itsItEnd)
            {
                currentName = itsItCurrent->first.as<std::string>();
            }
        }
 
        Iterator& operator++()
        {
            ++itsItCurrent;
            if(itsType == Member && itsItCurrent != itsItEnd)
            {
                currentName = itsItCurrent->first.as<std::string>();
            }
            return *this;
        }
 
        YAML::Node value()
        {
            switch(itsType)
            {
                case Value:
                    return *itsItCurrent;
                case Member:
                    return itsItCurrent->second;
                default:
                    throw ser20::Exception(
                        "YAMLInputArchive internal error: null or empty iterator to object or array!");
            }
        }
 
        const char* name() const
        {
            if(currentName != "")
            {
                return currentName.c_str();
            }
            else
            {
                return nullptr;
            }
        }
 
 
        inline void search(const char* searchName)
        {
            auto index = 0;
            const auto len = std::strlen(searchName);
            for(itsItCurrent = itsItBegin; itsItCurrent != itsItEnd; ++itsItCurrent, ++index)
            {
                currentName = itsItCurrent->first.as<std::string>();
                if((std::strncmp(searchName, currentName.c_str(), len) == 0) &&
                   (std::strlen(currentName.c_str()) == len))
                {
                    return;
                }
            }
 
            throw Exception("YAML Parsing failed - provided NVP (" + std::string(searchName) + ") not found");
        }
 
    private:
        YAMLIterator itsItBegin, itsItEnd; 
        YAMLIterator itsItCurrent;         
        std::string currentName;           
        Type itsType;                      
    };
 
 
    inline void search()
    {
        // The name an NVP provided with setNextName()
        if(itsNextName)
        {
            // The actual name of the current node
            auto const actualName = itsIteratorStack.back().name();
 
            // Do a search if we don't see a name coming up, or if the names don't match
            if(!actualName || std::strcmp(itsNextName, actualName) != 0)
            {
                itsIteratorStack.back().search(itsNextName);
            }
        }
 
        itsNextName = nullptr;
    }
 
public:
 
    void startNode()
    {
        search();
 
        auto value = itsIteratorStack.back().value();
 
        if(value.IsSequence())
        {
            itsIteratorStack.emplace_back(value.begin(), value.end(), Iterator::Type::Value);
        }
        else
        {
            itsIteratorStack.emplace_back(value.begin(), value.end(), Iterator::Type::Member);
        }
    }
 
    void finishNode()
    {
        itsIteratorStack.pop_back();
        ++itsIteratorStack.back();
    }
 
 
    const char* getNodeName() const
    {
        return itsIteratorStack.back().name();
    }
 
    void setNextName(const char* name)
    {
        itsNextName = name;
    }
 
    template<class T>
    inline void loadValue(T& val)
        requires(std::is_signed<T>::value && sizeof(T) < sizeof(int64_t))
    {
        search();
 
        val = static_cast<T>(itsIteratorStack.back().value().as<int>());
        ++itsIteratorStack.back();
    }
 
    template<class T>
    inline void loadValue(T& val)
        requires(std::is_unsigned<T>::value && sizeof(T) < sizeof(uint64_t) && !std::is_same<bool, T>::value)
    {
        search();
 
        val = static_cast<T>(itsIteratorStack.back().value().as<unsigned int>());
        ++itsIteratorStack.back();
    }
 
    void loadValue(bool& val)
    {
        search();
        val = itsIteratorStack.back().value().as<bool>();
        ++itsIteratorStack.back();
    }
    void loadValue(int64_t& val)
    {
        search();
        val = itsIteratorStack.back().value().as<int64_t>();
        ++itsIteratorStack.back();
    }
    void loadValue(uint64_t& val)
    {
        search();
        val = itsIteratorStack.back().value().as<uint64_t>();
        ++itsIteratorStack.back();
    }
    void loadValue(float& val)
    {
        search();
        val = static_cast<float>(itsIteratorStack.back().value().as<float>());
        ++itsIteratorStack.back();
    }
    void loadValue(double& val)
    {
        search();
        val = itsIteratorStack.back().value().as<double>();
        ++itsIteratorStack.back();
    }
    void loadValue(std::string& val)
    {
        search();
        val = itsIteratorStack.back().value().as<std::string>();
        ++itsIteratorStack.back();
    }
    void loadValue(std::nullptr_t&)
    {
        search(); /*TodoSER20_RAPIDJSON_ASSERT(itsIteratorStack.back().value().IsNull());*/
        ++itsIteratorStack.back();
    }
 
// Special cases to handle various flavors of long, which tend to conflict with
// the int32_t or int64_t on various compiler/OS combinations.  MSVC doesn't need any of this.
#ifndef _MSC_VER
private:
    template<class T>
    inline typename std::enable_if<sizeof(T) == sizeof(std::int32_t) && std::is_signed<T>::value, void>::type loadLong(
        T& l)
    {
        loadValue(reinterpret_cast<std::int32_t&>(l));
    }
 
    template<class T>
    inline typename std::enable_if<sizeof(T) == sizeof(std::int64_t) && std::is_signed<T>::value, void>::type loadLong(
        T& l)
    {
        loadValue(reinterpret_cast<std::int64_t&>(l));
    }
 
    template<class T>
    inline typename std::enable_if<sizeof(T) == sizeof(std::uint32_t) && !std::is_signed<T>::value, void>::type
    loadLong(T& lu)
    {
        loadValue(reinterpret_cast<std::uint32_t&>(lu));
    }
 
    template<class T>
    inline typename std::enable_if<sizeof(T) == sizeof(std::uint64_t) && !std::is_signed<T>::value, void>::type
    loadLong(T& lu)
    {
        loadValue(reinterpret_cast<std::uint64_t&>(lu));
    }
 
public:
    template<class T>
    inline typename std::enable_if<std::is_same<T, long>::value && sizeof(T) >= sizeof(std::int64_t) &&
                                       !std::is_same<T, std::int64_t>::value,
                                   void>::type
    loadValue(T& t)
    {
        loadLong(t);
    }
 
    template<class T>
    inline typename std::enable_if<std::is_same<T, unsigned long>::value && sizeof(T) >= sizeof(std::uint64_t) &&
                                       !std::is_same<T, std::uint64_t>::value,
                                   void>::type
    loadValue(T& t)
    {
        loadLong(t);
    }
#endif // _MSC_VER
 
private:
    void stringToNumber(std::string const& str, long long& val)
    {
        val = std::stoll(str);
    }
    void stringToNumber(std::string const& str, unsigned long long& val)
    {
        val = std::stoull(str);
    }
    void stringToNumber(std::string const& str, long double& val)
    {
        val = std::stold(str);
    }
 
public:
    template<class T>
    inline void loadValue(T& val)
        requires(std::is_arithmetic<T>::value && !std::is_same<T, long>::value &&
                 !std::is_same<T, unsigned long>::value && !std::is_same<T, std::int64_t>::value &&
                 !std::is_same<T, std::uint64_t>::value &&
                 (sizeof(T) >= sizeof(long double) || sizeof(T) >= sizeof(long long)))
    {
        std::string encoded;
        loadValue(encoded);
        stringToNumber(encoded, val);
    }
 
    void loadSize(size_type& size)
    {
        if(itsIteratorStack.size() == 1)
        {
            size = itsDocument.size();
        }
        else
        {
            size = (itsIteratorStack.rbegin() + 1)->value().size();
        }
    }
 
 
private:
    const char* itsNextName;                
    std::vector<Iterator> itsIteratorStack; 
    YAML::Node itsDocument;                 
 
}; // YAMLInputArchive
 
// ######################################################################
// YAMLArchive prologue and epilogue functions
// ######################################################################
 
// ######################################################################
 
template<class T>
inline void prologue(YAMLOutputArchive&, NameValuePair<T> const&)
{
}
 
template<class T>
inline void prologue(YAMLInputArchive&, NameValuePair<T> const&)
{
}
 
// ######################################################################
 
template<class T>
inline void epilogue(YAMLOutputArchive&, NameValuePair<T> const&)
{
}
 
 
template<class T>
inline void epilogue(YAMLInputArchive&, NameValuePair<T> const&)
{
}
 
// ######################################################################
 
template<class T>
inline void prologue(YAMLOutputArchive& ar, SizeTag<T> const&)
{
    ar.makeArray();
}
 
template<class T>
inline void prologue(YAMLInputArchive&, SizeTag<T> const&)
{
}
 
// ######################################################################
 
template<class T>
inline void epilogue(YAMLOutputArchive&, SizeTag<T> const&)
{
}
 
template<class T>
inline void epilogue(YAMLInputArchive&, SizeTag<T> const&)
{
}
 
// ######################################################################
 
template<class T>
inline void prologue(YAMLOutputArchive& ar, T const&)
    requires(!std::is_arithmetic_v<T> &&
             !traits::has_minimal_base_class_serialization<T,
                                                           traits::has_minimal_output_serialization,
                                                           YAMLOutputArchive>::value &&
             !traits::has_minimal_output_serialization<T, YAMLOutputArchive>::value)
{
    ar.startNode();
}
 
template<class T>
inline void prologue(YAMLInputArchive& ar, T const&)
    requires(!std::is_arithmetic_v<T> &&
             !traits::has_minimal_base_class_serialization<T,
                                                           traits::has_minimal_input_serialization,
                                                           YAMLInputArchive>::value &&
             !traits::has_minimal_input_serialization<T, YAMLInputArchive>::value)
{
    ar.startNode();
}
 
// ######################################################################
 
template<class T>
inline void epilogue(YAMLOutputArchive& ar, T const&)
    requires(!std::is_arithmetic_v<T> &&
             !traits::has_minimal_base_class_serialization<T,
                                                           traits::has_minimal_output_serialization,
                                                           YAMLOutputArchive>::value &&
             !traits::has_minimal_output_serialization<T, YAMLOutputArchive>::value)
{
    ar.finishNode();
}
 
template<class T>
inline void epilogue(YAMLInputArchive& ar, T const&)
    requires(!std::is_arithmetic_v<T> &&
             !traits::has_minimal_base_class_serialization<T,
                                                           traits::has_minimal_input_serialization,
                                                           YAMLInputArchive>::value &&
             !traits::has_minimal_input_serialization<T, YAMLInputArchive>::value)
{
    ar.finishNode();
}
 
// ######################################################################
inline void prologue(YAMLOutputArchive& ar, std::nullptr_t const&)
{
    ar.writeName();
}
 
inline void prologue(YAMLInputArchive&, std::nullptr_t const&)
{
}
 
// ######################################################################
inline void epilogue(YAMLOutputArchive&, std::nullptr_t const&)
{
}
 
inline void epilogue(YAMLInputArchive&, std::nullptr_t const&)
{
}
 
// ######################################################################
template<class T>
inline void prologue(YAMLOutputArchive& ar, T const&)
    requires(std::is_arithmetic_v<T>)
{
    ar.writeName();
}
 
template<class T>
inline void prologue(YAMLInputArchive&, T const&)
    requires(std::is_arithmetic_v<T>)
{
}
 
// ######################################################################
template<class T>
inline void epilogue(YAMLOutputArchive&, T const&)
    requires(std::is_arithmetic_v<T>)
{
}
 
template<class T>
inline void epilogue(YAMLInputArchive&, T const&)
    requires(std::is_arithmetic_v<T>)
{
}
 
// ######################################################################
template<class CharT, class Traits, class Alloc>
inline void prologue(YAMLOutputArchive& ar, std::basic_string<CharT, Traits, Alloc> const&)
{
    ar.writeName();
}
 
template<class CharT, class Traits, class Alloc>
inline void prologue(YAMLInputArchive&, std::basic_string<CharT, Traits, Alloc> const&)
{
}
 
// ######################################################################
template<class CharT, class Traits, class Alloc>
inline void epilogue(YAMLOutputArchive&, std::basic_string<CharT, Traits, Alloc> const&)
{
}
 
template<class CharT, class Traits, class Alloc>
inline void epilogue(YAMLInputArchive&, std::basic_string<CharT, Traits, Alloc> const&)
{
}
 
// ######################################################################
// Common YAMLArchive serialization functions
// ######################################################################
template<class T>
inline void SER20_SAVE_FUNCTION_NAME(YAMLOutputArchive& ar, NameValuePair<T> const& t)
{
    ar.setNextName(t.name);
    ar(t.value);
}
 
template<class T>
inline void SER20_LOAD_FUNCTION_NAME(YAMLInputArchive& ar, NameValuePair<T>& t)
{
    ar.setNextName(t.name);
    ar(t.value);
}
 
inline void SER20_SAVE_FUNCTION_NAME(YAMLOutputArchive& ar, std::nullptr_t const& t)
{
    ar.saveValue(t);
}
 
inline void SER20_LOAD_FUNCTION_NAME(YAMLInputArchive& ar, std::nullptr_t& t)
{
    ar.loadValue(t);
}
 
template<class T>
inline void SER20_SAVE_FUNCTION_NAME(YAMLOutputArchive& ar, T const& t)
    requires(std::is_arithmetic_v<T>)
{
    ar.saveValue(t);
}
 
template<class T>
inline void SER20_LOAD_FUNCTION_NAME(YAMLInputArchive& ar, T& t)
    requires(std::is_arithmetic_v<T>)
{
    ar.loadValue(t);
}
 
template<class CharT, class Traits, class Alloc>
inline void SER20_SAVE_FUNCTION_NAME(YAMLOutputArchive& ar, std::basic_string<CharT, Traits, Alloc> const& str)
{
    ar.saveValue(str);
}
 
template<class CharT, class Traits, class Alloc>
inline void SER20_LOAD_FUNCTION_NAME(YAMLInputArchive& ar, std::basic_string<CharT, Traits, Alloc>& str)
{
    ar.loadValue(str);
}
 
// ######################################################################
template<class T>
inline void SER20_SAVE_FUNCTION_NAME(YAMLOutputArchive&, SizeTag<T> const&)
{
    // nothing to do here, we don't explicitly save the size
}
 
template<class T>
inline void SER20_LOAD_FUNCTION_NAME(YAMLInputArchive& ar, SizeTag<T>& st)
{
    ar.loadSize(st.size);
}
 
} // namespace ser20
 
// register archives for polymorphic support
SER20_REGISTER_ARCHIVE(ser20::YAMLInputArchive)
SER20_REGISTER_ARCHIVE(ser20::YAMLOutputArchive)
 
// tie input and output archives together
SER20_SETUP_ARCHIVE_TRAITS(ser20::YAMLInputArchive, ser20::YAMLOutputArchive)
 
#endif // SER20_ARCHIVES_YAML_HPP_