object_fwd.hpp

Go to the documentation of this file.

//
// MessagePack for C++ static resolution routine
//
// Copyright (C) 2008-2014 FURUHASHI Sadayuki and KONDO Takatoshi
//
//    Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//    http://www.boost.org/LICENSE_1_0.txt)
//
 
#ifndef MSGPACK_V1_OBJECT_FWD_HPP
#define MSGPACK_V1_OBJECT_FWD_HPP
 
#include "msgpack/object_fwd_decl.hpp"
 
namespace msgpack {
 
MSGPACK_API_VERSION_NAMESPACE(v1) {
 
struct object_array {
    uint32_t size;
    msgpack::object* ptr;
};
 
struct object_map {
    uint32_t size;
    msgpack::object_kv* ptr;
};
 
struct object_str {
    uint32_t size;
    const char* ptr;
};
 
struct object_bin {
    uint32_t size;
    const char* ptr;
};
 
struct object_ext {
    int8_t type() const { return static_cast<int8_t>(ptr[0]); }
    const char* data() const { return &ptr[1]; }
    uint32_t size;
    const char* ptr;
};
 
 
#if !defined(MSGPACK_USE_CPP03)
 
template <typename T>
struct has_as {
private:
    template <typename U>
    static auto check_(U*) ->
        // Check v1 specialization
        typename std::is_same<
            decltype(adaptor::as<U>()(std::declval<msgpack::object>())),
            T
        >::type;
    template <typename...>
    static std::false_type check_(...);
public:
    using type = decltype(check_<T>(MSGPACK_NULLPTR));
    static constexpr bool value = type::value;
};
 
#endif // !defined(MSGPACK_USE_CPP03)
 
 
struct object {
    union union_type {
        bool boolean;
        uint64_t u64;
        int64_t  i64;
#if defined(MSGPACK_USE_LEGACY_NAME_AS_FLOAT)
        MSGPACK_DEPRECATED("please use f64 instead")
        double   dec; // obsolete
#endif // MSGPACK_USE_LEGACY_NAME_AS_FLOAT
        double   f64;
        msgpack::object_array array;
        msgpack::object_map map;
        msgpack::object_str str;
        msgpack::object_bin bin;
        msgpack::object_ext ext;
    };
 
    msgpack::type::object_type type;
    union_type via;
 
 
    bool is_nil() const { return type == msgpack::type::NIL; }
 
#if defined(MSGPACK_USE_CPP03)
 
 
    template <typename T>
    T as() const;
 
#else  // defined(MSGPACK_USE_CPP03)
 
 
    template <typename T>
    typename std::enable_if<msgpack::has_as<T>::value, T>::type as() const;
 
 
    template <typename T>
    typename std::enable_if<!msgpack::has_as<T>::value, T>::type as() const;
 
#endif // defined(MSGPACK_USE_CPP03)
 
 
    template <typename T>
    typename msgpack::enable_if<
        !msgpack::is_array<T>::value && !msgpack::is_pointer<T>::value,
        T&
    >::type
    convert(T& v) const;
 
    template <typename T, std::size_t N>
    T (&convert(T(&v)[N]) const)[N];
 
 
#if !defined(MSGPACK_DISABLE_LEGACY_CONVERT)
 
    template <typename T>
    MSGPACK_DEPRECATED("please use reference version instead")
    typename msgpack::enable_if<
        msgpack::is_pointer<T>::value,
        T
    >::type
    convert(T v) const;
#endif // !defined(MSGPACK_DISABLE_LEGACY_CONVERT)
 
 
    template <typename T>
    bool convert_if_not_nil(T& v) const;
 
    object();
 
 
    template <typename T>
    explicit object(const T& v);
 
 
    template <typename T>
    object(const T& v, msgpack::zone& z);
 
 
    template <typename T>
    MSGPACK_DEPRECATED("please use zone reference version instead of the pointer version")
    object(const T& v, msgpack::zone* z);
 
    template <typename T>
    object& operator=(const T& v);
 
    struct with_zone;
 
protected:
    struct implicit_type;
 
public:
    implicit_type convert() const;
};
 
class type_error : public std::bad_cast { };
 
struct object::implicit_type {
    implicit_type(object const& o) : obj(o) { }
    ~implicit_type() { }
 
    template <typename T>
    operator T();
 
private:
    object const& obj;
};
 
} // MSGPACK_API_VERSION_NAMESPACE(v1)
 
} // namespace msgpack
 
#endif // MSGPACK_V1_OBJECT_FWD_HPP