type_discovery.hpp

Go to the documentation of this file.

/***************************************************************************
  tag: The SourceWorks  Tue Sep 7 00:55:18 CEST 2010  type_discovery.hpp

                        type_discovery.hpp -  description
                           -------------------
    begin                : Tue September 07 2010
    copyright            : (C) 2010 The SourceWorks
    email                : peter@thesourceworks.com

 ***************************************************************************
 *   This library is free software; you can redistribute it and/or         *
 *   modify it under the terms of the GNU General Public                   *
 *   License as published by the Free Software Foundation;                 *
 *   version 2 of the License.                                             *
 *                                                                         *
 *   As a special exception, you may use this file as part of a free       *
 *   software library without restriction.  Specifically, if other files   *
 *   instantiate templates or use macros or inline functions from this     *
 *   file, or you compile this file and link it with other files to        *
 *   produce an executable, this file does not by itself cause the         *
 *   resulting executable to be covered by the GNU General Public          *
 *   License.  This exception does not however invalidate any other        *
 *   reasons why the executable file might be covered by the GNU General   *
 *   Public License.                                                       *
 *                                                                         *
 *   This library 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     *
 *   Lesser General Public License for more details.                       *
 *                                                                         *
 *   You should have received a copy of the GNU General Public             *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 59 Temple Place,                                    *
 *   Suite 330, Boston, MA  02111-1307  USA                                *
 *                                                                         *
 ***************************************************************************/


#ifndef TYPE_DISCOVERY_HPP_
#define TYPE_DISCOVERY_HPP_

// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
// (C) Copyright 2009 Peter Soetens - http://www.thesourceworks.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)

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


#include <cassert>
#include <boost/version.hpp>
#if BOOST_VERSION >= 106400
// The class name has been changed from boost::serialization::array<T> to array_wrapper<T> in Boost 1.61,
// but the header has only be renamed in Boost 1.64. Starting from Boost 1.65 array.hpp includes array_wrapper.hpp,
// but with 1.64 compilation fails if array_wrapper.hpp is not included.
# include <boost/serialization/array_wrapper.hpp>
#else
# include <boost/serialization/array.hpp>
#endif
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/is_bitwise_serializable.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/string.hpp>
#include <boost/archive/detail/iserializer.hpp>
#include <boost/archive/detail/oserializer.hpp>
#include <boost/archive/archive_exception.hpp>
#include <boost/config.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/array.hpp>

#include <vector>
#include <string>
#include "../base/DataSourceBase.hpp"
#include "../internal/PartDataSource.hpp"
#include "../internal/DataSources.hpp"
#include "../internal/Reference.hpp"
#include "carray.hpp"

namespace RTT
{
    namespace types
    {
        class type_discovery
        {
        public:
            base::DataSourceBase::shared_ptr mparent;

            typedef std::vector<base::DataSourceBase::shared_ptr> Parts;
            typedef std::vector<std::string> PartNames;
            Parts mparts;

            PartNames mnames;

            std::string membername;

            internal::Reference* mref;

            typedef char Elem;
            typedef boost::mpl::bool_<true> is_loading;
            typedef boost::mpl::bool_<false> is_saving;

            type_discovery(base::DataSourceBase::shared_ptr parent) :
                mparent(parent), mref(0)
            {
            }

            type_discovery() :
                mparent(), mref(0)
            {
            }

            base::DataSourceBase::shared_ptr getMember(const std::string name) {
                PartNames::iterator it = find( mnames.begin(), mnames.end(), name);
                if ( it != mnames.end() && mparts.size() == mnames.size() )
                    return mparts.at( it - mnames.begin() );
                return base::DataSourceBase::shared_ptr();
            }

            template<class T>
            void discover( T& t) {
#if BOOST_VERSION >= 104100
                boost::archive::detail::load_non_pointer_type<type_discovery>::load_only::invoke(*this,t);
#else
                boost::archive::detail::load_non_pointer_type<type_discovery,T>::load_only::invoke(*this,t);
#endif
            }

            template<class T>
            base::DataSourceBase::shared_ptr discoverMember( T& t, const std::string name) {
                membername = name;
                discover( t );
                if ( ! mparts.empty() )
                    return mparts[0];
                return base::DataSourceBase::shared_ptr();
            }

            template<class T>
            bool referenceMember(internal::Reference* ref, T& t, const std::string name) {
                assert(ref);
                membername = name;
                mref = ref;
                discover( t );
                if (mref == 0) // we found it
                    return true;
                return false;
            }

            unsigned int get_library_version() { return 0; }

            void reset_object_address(const void * new_address, const void * old_address) {}

            void delete_created_pointers() {}

            template<class T>
            const boost::archive::detail::basic_pointer_iserializer *
            register_type(T * = NULL) {return 0;}

            void load_object(void *x, const boost::archive::detail::basic_oserializer & bos)
            {
                assert(false);
            }

            template<class T>
            type_discovery &operator>>(T &t)
            {
                return load_a_type(t, boost::mpl::bool_<boost::serialization::implementation_level<T>::value == boost::serialization::primitive_type>());
            }

            template<class T>
            type_discovery &operator&(T &t)
            {
                return this->operator>>(t);
            }

            template<class T>
            type_discovery &load_a_type(T &t, boost::mpl::true_)
            {
                // stores the part
                if (mparent) {
                    mparts.push_back(new internal::PartDataSource<T> (t, mparent));
                }
                return *this;
            }

            template<class T>
            type_discovery &load_a_type(T &t, boost::mpl::false_)
            {
                mparts.push_back(new internal::PartDataSource<T> (t, mparent));
                return *this;
            }

            template<class T>
#if BOOST_VERSION >= 106100
            type_discovery &load_a_type(const boost::serialization::array_wrapper<T> &t, boost::mpl::false_)
#else
            type_discovery &load_a_type(const boost::serialization::array<T> &t, boost::mpl::false_)
#endif
            {
                mparts.push_back(new internal::PartDataSource< carray<T> > ( carray<T>(t), mparent) );
                return *this;
            }

            template<class T, std::size_t N>
            type_discovery &load_a_type(boost::array<T,N> &t, boost::mpl::false_)
            {
                mparts.push_back(new internal::PartDataSource< carray<T> > ( carray<T>(t), mparent) );
                return *this;
            }

            template<class T>
            type_discovery &load_a_type(const T* &, boost::mpl::false_)
            {
                //pointers can not be serialized.
                //BOOST_STATIC_ASSERT( boost::mpl::false_ );
                return *this;
            }

            template<class T>
            type_discovery &load_a_type(const boost::serialization::nvp<T> & t, boost::mpl::false_)
            {
                // check for single-member extraction first:
                if ( !membername.empty() ) {
                    // Only serialize if the name matches:
                    if ( t.name() == membername ) {
                        if ( !mref ) {
                            *this & t.value();
                        } else {
                            mref->setReference( (void*) & t.value() );
                            mref = 0; // signals' we're done.
                        }
                    }
                } else {
                    // Full extraction of all parts:
                    // store name of member
                    mnames.push_back( t.name() );

                    // serialize the data as usual
                    if (mparent)
                        *this & t.value();
                }

                return *this;
            }
        };
    }
}

#endif /* TYPE_DISCOVERY_HPP_ */