FM / serialization

/usr/include/boost/serialization

Name	Size	Mode	Actions
detail/	-	0755	rm
access.hpp	4374	0644	edit dl rm
archive_input_unordered_map.hpp	2794	0644	edit dl rm
archive_input_unordered_set.hpp	2275	0644	edit dl rm
array.hpp	1443	0644	edit dl rm
array_optimization.hpp	1381	0644	edit dl rm
array_wrapper.hpp	3271	0644	edit dl rm
assume_abstract.hpp	1935	0644	edit dl rm
base_object.hpp	3008	0644	edit dl rm
binary_object.hpp	2295	0644	edit dl rm
bitset.hpp	1953	0644	edit dl rm
boost_array.hpp	949	0644	edit dl rm
boost_unordered_map.hpp	4272	0644	edit dl rm
boost_unordered_set.hpp	4044	0644	edit dl rm
collections_load_imp.hpp	2917	0644	edit dl rm
collections_save_imp.hpp	2306	0644	edit dl rm
collection_size_type.hpp	1764	0644	edit dl rm
collection_size_type copy.hpp	3415	0644	edit dl rm
collection_traits.hpp	3679	0644	edit dl rm
complex.hpp	2219	0644	edit dl rm
config.hpp	2734	0644	edit dl rm
deque.hpp	2324	0644	edit dl rm
export.hpp	8215	0644	edit dl rm
extended_type_info.hpp	3604	0644	edit dl rm
extended_type_info_no_rtti.hpp	6367	0644	edit dl rm
extended_type_info_typeid.hpp	5661	0644	edit dl rm
factory.hpp	4099	0644	edit dl rm
force_include.hpp	2073	0644	edit dl rm
forward_list.hpp	3865	0644	edit dl rm
hash_collections_load_imp.hpp	2686	0644	edit dl rm
hash_collections_save_imp.hpp	3435	0644	edit dl rm
hash_map.hpp	6313	0644	edit dl rm
hash_set.hpp	5884	0644	edit dl rm
is_bitwise_serializable.hpp	1399	0644	edit dl rm
item_version_type.hpp	1856	0644	edit dl rm
level.hpp	3621	0644	edit dl rm
level_enum.hpp	2140	0644	edit dl rm
library_version_type.hpp	2045	0644	edit dl rm
list.hpp	2485	0644	edit dl rm
map.hpp	4447	0644	edit dl rm
nvp.hpp	3538	0644	edit dl rm
optional.hpp	3201	0644	edit dl rm
priority_queue.hpp	2413	0644	edit dl rm
queue.hpp	2094	0644	edit dl rm
scoped_ptr.hpp	1552	0644	edit dl rm
serialization.hpp	4678	0644	edit dl rm
set.hpp	4284	0644	edit dl rm
shared_ptr.hpp	9821	0644	edit dl rm
shared_ptr_132.hpp	7370	0644	edit dl rm
shared_ptr_helper.hpp	7047	0644	edit dl rm
singleton.hpp	7603	0644	edit dl rm
slist.hpp	4828	0644	edit dl rm
smart_cast.hpp	8944	0644	edit dl rm
split_free.hpp	2734	0644	edit dl rm
split_member.hpp	2640	0644	edit dl rm
stack.hpp	2093	0644	edit dl rm
state_saver.hpp	2691	0644	edit dl rm
static_warning.hpp	3844	0644	edit dl rm
string.hpp	976	0644	edit dl rm
strong_typedef.hpp	3084	0644	edit dl rm
throw_exception.hpp	947	0644	edit dl rm
tracking.hpp	3990	0644	edit dl rm
tracking_enum.hpp	1227	0644	edit dl rm
traits.hpp	2017	0644	edit dl rm
type_info_implementation.hpp	2621	0644	edit dl rm
unique_ptr.hpp	1971	0644	edit dl rm
unordered_collections_load_imp.hpp	2438	0644	edit dl rm
unordered_collections_save_imp.hpp	2993	0644	edit dl rm
unordered_map.hpp	4164	0644	edit dl rm
unordered_set.hpp	4024	0644	edit dl rm
utility.hpp	1789	0644	edit dl rm
valarray.hpp	2754	0644	edit dl rm
variant.hpp	5122	0644	edit dl rm
vector.hpp	6924	0644	edit dl rm
vector_135.hpp	942	0644	edit dl rm
version.hpp	4291	0644	edit dl rm
void_cast.hpp	8747	0644	edit dl rm
void_cast_fwd.hpp	1187	0644	edit dl rm
weak_ptr.hpp	2437	0644	edit dl rm
wrapper.hpp	1907	0644	edit dl rm

Edit: /usr/include/boost/serialization/void_cast.hpp (8747B)

#ifndef BOOST_SERIALIZATION_VOID_CAST_HPP
#define BOOST_SERIALIZATION_VOID_CAST_HPP

// MS compatible compilers support #pragma once
#if defined(_MSC_VER)
# pragma once
#endif

/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// void_cast.hpp:   interface for run-time casting of void pointers.

// (C) Copyright 2002-2009 Robert Ramey - http://www.rrsd.com .
// Use, modification and distribution is subject to 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)
// gennadiy.rozental@tfn.com

//  See http://www.boost.org for updates, documentation, and revision history.

#include <cstddef> // for ptrdiff_t
#include <boost/config.hpp>
#include <boost/noncopyable.hpp>

#include <boost/serialization/smart_cast.hpp>
#include <boost/serialization/singleton.hpp>
#include <boost/serialization/force_include.hpp>
#include <boost/serialization/type_info_implementation.hpp>
#include <boost/serialization/extended_type_info.hpp>
#include <boost/type_traits/is_virtual_base_of.hpp>
#include <boost/type_traits/aligned_storage.hpp>
#include <boost/serialization/void_cast_fwd.hpp>

#include <boost/serialization/config.hpp>
#include <boost/config/abi_prefix.hpp> // must be the last header

#ifdef BOOST_MSVC
#  pragma warning(push)
#  pragma warning(disable : 4251 4231 4660 4275)
#endif

namespace boost {
namespace serialization {

class extended_type_info;

// Given a void *, assume that it really points to an instance of one type
// and alter it so that it would point to an instance of a related type.
// Return the altered pointer. If there exists no sequence of casts that
// can transform from_type to to_type, return a NULL.

BOOST_SERIALIZATION_DECL void const *
void_upcast(
    extended_type_info const & derived,
    extended_type_info const & base,
    void const * const t
);

inline void *
void_upcast(
    extended_type_info const & derived,
    extended_type_info const & base,
    void * const t
){
    return const_cast<void*>(void_upcast(
        derived,
        base,
        const_cast<void const *>(t)
    ));
}

BOOST_SERIALIZATION_DECL void const *
void_downcast(
    extended_type_info const & derived,
    extended_type_info const & base,
    void const * const t
);

inline void *
void_downcast(
    extended_type_info const & derived,
    extended_type_info const & base,
    void * const t
){
    return const_cast<void*>(void_downcast(
        derived,
        base,
        const_cast<void const *>(t)
    ));
}

namespace void_cast_detail {

class BOOST_SYMBOL_VISIBLE void_caster :
    private boost::noncopyable
{
    friend
    BOOST_SERIALIZATION_DECL void const *
    boost::serialization::void_upcast(
        extended_type_info const & derived,
        extended_type_info const & base,
        void const * const
    );
    friend
    BOOST_SERIALIZATION_DECL void const *
    boost::serialization::void_downcast(
        extended_type_info const & derived,
        extended_type_info const & base,
        void const * const
    );
protected:
    BOOST_SERIALIZATION_DECL void recursive_register(bool includes_virtual_base = false) const;
    BOOST_SERIALIZATION_DECL void recursive_unregister() const;
    virtual bool has_virtual_base() const = 0;
public:
    // Data members
    const extended_type_info * m_derived;
    const extended_type_info * m_base;
    /*const*/ std::ptrdiff_t m_difference;
    void_caster const * const m_parent;

// note that void_casters are keyed on value of
    // member extended type info records - NOT their
    // addresses.  This is necessary in order for the
    // void cast operations to work across dll and exe
    // module boundaries.
    bool operator<(const void_caster & rhs) const;

const void_caster & operator*(){
        return *this;
    }
    // each derived class must re-implement these;
    virtual void const * upcast(void const * const t) const = 0;
    virtual void const * downcast(void const * const t) const = 0;
    // Constructor
    void_caster(
        extended_type_info const * derived,
        extended_type_info const * base,
        std::ptrdiff_t difference = 0,
        void_caster const * const parent = 0
    ) :
        m_derived(derived),
        m_base(base),
        m_difference(difference),
        m_parent(parent)
    {}
    virtual ~void_caster(){}
};

#ifdef BOOST_MSVC
#  pragma warning(push)
#  pragma warning(disable : 4251 4231 4660 4275 4511 4512)
#endif

template <class Derived, class Base>
class BOOST_SYMBOL_VISIBLE void_caster_primitive :
    public void_caster
{
    void const * downcast(void const * const t) const BOOST_OVERRIDE {
        const Derived * d =
            boost::serialization::smart_cast<const Derived *, const Base *>(
                static_cast<const Base *>(t)
            );
        return d;
    }
    void const * upcast(void const * const t) const BOOST_OVERRIDE {
        const Base * b =
            boost::serialization::smart_cast<const Base *, const Derived *>(
                static_cast<const Derived *>(t)
            );
        return b;
    }
    bool has_virtual_base() const BOOST_OVERRIDE {
        return false;
    }
public:
    void_caster_primitive();
    ~void_caster_primitive() BOOST_OVERRIDE;

private:
    static std::ptrdiff_t base_offset() {
        typename boost::aligned_storage<sizeof(Derived)>::type data;
        return reinterpret_cast<char*>(&data)
             - reinterpret_cast<char*>(
                   static_cast<Base*>(
                       reinterpret_cast<Derived*>(&data)));
    }
};

template <class Derived, class Base>
void_caster_primitive<Derived, Base>::void_caster_primitive() :
    void_caster(
        & type_info_implementation<Derived>::type::get_const_instance(),
        & type_info_implementation<Base>::type::get_const_instance(),
        base_offset()
    )
{
    recursive_register();
}

template <class Derived, class Base>
void_caster_primitive<Derived, Base>::~void_caster_primitive(){
    recursive_unregister();
}

template <class Derived, class Base>
class BOOST_SYMBOL_VISIBLE void_caster_virtual_base :
    public void_caster
{
    bool has_virtual_base() const BOOST_OVERRIDE {
        return true;
    }
public:
    void const * downcast(void const * const t) const BOOST_OVERRIDE {
        const Derived * d =
            dynamic_cast<const Derived *>(
                static_cast<const Base *>(t)
            );
        return d;
    }
    void const * upcast(void const * const t) const BOOST_OVERRIDE {
        const Base * b =
            dynamic_cast<const Base *>(
                static_cast<const Derived *>(t)
            );
        return b;
    }
    void_caster_virtual_base();
    ~void_caster_virtual_base() BOOST_OVERRIDE;
};

#ifdef BOOST_MSVC
#pragma warning(pop)
#endif

template <class Derived, class Base>
void_caster_virtual_base<Derived,Base>::void_caster_virtual_base() :
    void_caster(
        & (type_info_implementation<Derived>::type::get_const_instance()),
        & (type_info_implementation<Base>::type::get_const_instance())
    )
{
    recursive_register(true);
}

template <class Derived, class Base>
void_caster_virtual_base<Derived,Base>::~void_caster_virtual_base(){
    recursive_unregister();
}

template <class Derived, class Base>
struct BOOST_SYMBOL_VISIBLE void_caster_base :
    public void_caster
{
    typedef
        typename mpl::eval_if<boost::is_virtual_base_of<Base,Derived>,
            mpl::identity<
                void_cast_detail::void_caster_virtual_base<Derived, Base>
            >
        ,// else
            mpl::identity<
                void_cast_detail::void_caster_primitive<Derived, Base>
            >
        >::type type;
};

} // void_cast_detail

template<class Derived, class Base>
BOOST_DLLEXPORT
inline const void_cast_detail::void_caster & void_cast_register(
    Derived const * /* dnull = NULL */,
    Base const * /* bnull = NULL */
){
    typedef
        typename mpl::eval_if<boost::is_virtual_base_of<Base,Derived>,
            mpl::identity<
                void_cast_detail::void_caster_virtual_base<Derived, Base>
            >
        ,// else
            mpl::identity<
                void_cast_detail::void_caster_primitive<Derived, Base>
            >
        >::type typex;
    return singleton<typex>::get_const_instance();
}

template<class Derived, class Base>
class BOOST_SYMBOL_VISIBLE void_caster :
    public void_cast_detail::void_caster_base<Derived, Base>::type
{
};

} // namespace serialization
} // namespace boost

#ifdef BOOST_MSVC
#  pragma warning(pop)
#endif

#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas

#endif // BOOST_SERIALIZATION_VOID_CAST_HPP

cmd: