Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

RMI for C++

, 6 Aug 2009 CPOL
User-friendly remote method invocation in C++.
rcf.zip
RCF
demo
vs2003
RCF
Client
Server
doc
include
RCF
Connection.inl
Marshal.inl
Multiplexer.inl
RCF.inl
RcfServer.inl
ServerStub.inl
Protocol
util
Platform
Compiler
bcc55
cw80
gcc32
icl70
msvc71
Library
bcc55
cw80
gcc32
msvc60
msvc71
Machine
SPARC
x86
OS
Cygwin
Unix
Windows
System
NonWindows
Windows
Threads
SF
src
RCF
Protocol
util
SF
test
Jamfile
Jamrules
borland
Jamfile
Jamrules
vs2003
RCF
RCF
RCFTest
//*****************************************************************************
// RCF - Remote Call Framework
// Copyright (c) 2005, Jarl Lindrud.
// Contact: jlindrud@hotmail.com .
//
// Distributed under the so-called MIT license, see accompanying file license.txt.
//*****************************************************************************

#ifndef _SF_SERIALIZER_HPP_
#define _SF_SERIALIZER_HPP_

#include <SF/Archive.hpp>
#include <SF/I_Stream.hpp>
#include <SF/Registry.hpp>
#include <SF/SerializePolymorphic.hpp>
#include <SF/SfNew.hpp>
#include <SF/Tools.hpp>


namespace boost {
    namespace serialization {
        template<class Base, class Derived>
        const Base & base_object(const Derived & d);
    }
}

namespace SF {

    // Generic serializer, subclassed by all other serializers

    class SerializerBase : boost::noncopyable
    {
    private:
        bool invokeRead(Archive &ar);
        bool invokeWrite(Archive &ar);

        // Following are overridden to provide type-specific operations.
        virtual std::string getTypeName() = 0;
        virtual void newObject(Archive &ar) = 0;
        virtual bool isDerived() = 0;
        virtual std::string getDerivedTypeName() = 0;
        virtual void getSerializerPolymorphic(const std::string &derivedTypeName) = 0;
        virtual bool invokeSerializerPolymorphic(SF::Archive &) = 0;
        virtual void serializeContents(Archive &ar) = 0;
        virtual void addToInputContext(I_Stream *, const UInt32 &) = 0;
        virtual bool queryInputContext(I_Stream *, const UInt32 &) = 0; 
        virtual void addToOutputContext(I_Stream *, UInt32 &) = 0;
        virtual bool queryOutputContext(I_Stream *, UInt32 &) = 0;
        virtual void setFromId() = 0;
        virtual void setToNull() = 0;
        virtual bool isNull() = 0;
        virtual bool isNonAtomic() = 0;

    public:
        SerializerBase();
        virtual ~SerializerBase();
        bool invoke(Archive &ar);
    };

    //---------------------------------------------------------------------
    // Type-specific serializers

    template<typename T>
    class Serializer : public SerializerBase 
    {
    public:
        Serializer(T **ppt) :
            ppt(ppt), 
            pf(),
            id()
        {}

    private:
        typedef ObjectId IdT;
        T **ppt;
        I_SerializerPolymorphic *pf;
        IdT id;

        std::string getTypeName()
        {
            return SF::Registry::getSingleton().template getTypeName<T>();
        }

        void newObject(Archive &ar) 
        {
            *ppt = sfNew((T *) NULL, (T **) NULL, ar); 
        }

        bool isDerived() 
        {
            if (*ppt && typeid(T) != typeid(**ppt)) 
            {
                if (!SF::Registry::getSingleton().isTypeRegistered( typeid(**ppt) ))
                    SF_THROW(SF::Exception, "type not registered")(typeid(T))(typeid(**ppt));
                return true;
            }
            return false;
        }

        std::string getDerivedTypeName() 
        { 
            return SF::Registry::getSingleton().getTypeName( typeid(**ppt) );
        }

        void getSerializerPolymorphic(const std::string &derivedTypeName) 
        { 
            pf = & SF::Registry::getSingleton().template getSerializerPolymorphic<T>(derivedTypeName);
        }

        bool invokeSerializerPolymorphic(SF::Archive &ar) 
        { 
            SF_ASSERT(pf);
            void **ppvb = (void **) (ppt); // not even reinterpret_cast wants to touch this...
            return pf->invoke(ppvb, ar);
        }

        void serializeContents(Archive &ar) 
        { 
            preserialize(ar, *ppt, 0);
        }

        void addToInputContext(SF::I_Stream *stream, const UInt32 &nid)
        {
            I_ContextRead &ctx = dynamic_cast<I_WithContextRead *>(stream)->getContext();
            ctx.add(nid, IdT( (void *) (*ppt), &typeid(T)));
        }

        bool queryInputContext(SF::I_Stream *stream, const UInt32 &nid)
        {
            I_ContextRead &ctx = dynamic_cast<I_WithContextRead *>(stream)->getContext();
            return ctx.query(nid, id);
        } 

        void addToOutputContext(SF::I_Stream *stream, UInt32 &nid)
        {
            I_ContextWrite &ctx = dynamic_cast<I_WithContextWrite *>(stream)->getContext();
            ctx.add( IdT( (void *) *ppt, &typeid(T)), nid);
        }

        bool queryOutputContext(SF::I_Stream *stream, UInt32 &nid)
        {
            I_ContextWrite &ctx = dynamic_cast<I_WithContextWrite *>(stream)->getContext();
            return ctx.query( IdT( (void *) *ppt, &typeid(T)), nid);
        }

        void setFromId()        
        { 
            *ppt = reinterpret_cast<T *>(id.first); 
        }

        void setToNull()
        { 
            *ppt = NULL; 
        }

        bool isNull() 
        { 
            return *ppt == NULL; 
        }

        bool isNonAtomic()
        {
            bool isFundamental = boost::is_fundamental<T>::value;
            return !isFundamental;
        }

    };

    template<typename T> struct GetIndirection                         { typedef Meta::Int<0> Level; typedef T Base; };
    template<typename T> struct GetIndirection<T *>                    { typedef Meta::Int<1> Level; typedef T Base; };
    template<typename T> struct GetIndirection<T const *>              { typedef Meta::Int<1> Level; typedef T Base; };
    template<typename T> struct GetIndirection<T * const>              { typedef Meta::Int<1> Level; typedef T Base; };
    template<typename T> struct GetIndirection<T const * const>        { typedef Meta::Int<1> Level; typedef T Base; };
    template<typename T> struct GetIndirection<T **>                   { typedef Meta::Int<2> Level; typedef T Base; };
    template<typename T> struct GetIndirection<T **const>              { typedef Meta::Int<2> Level; typedef T Base; };
    template<typename T> struct GetIndirection<T *const*>              { typedef Meta::Int<2> Level; typedef T Base; };
    template<typename T> struct GetIndirection<T const**>              { typedef Meta::Int<2> Level; typedef T Base; };
    template<typename T> struct GetIndirection<T *const*const>         { typedef Meta::Int<2> Level; typedef T Base; };
    template<typename T> struct GetIndirection<T const**const>         { typedef Meta::Int<2> Level; typedef T Base; };
    template<typename T> struct GetIndirection<T const*const*>         { typedef Meta::Int<2> Level; typedef T Base; };
    template<typename T> struct GetIndirection<T const*const*const>    { typedef Meta::Int<2> Level; typedef T Base; };

    template<typename U, typename T, typename TC>
    class InvokeSerializer;

    template<typename U, typename T>
    class InvokeSerializer<U, T, Meta::Int<0> >
    {
    public:
        bool operator()(const U &u, Archive &archive)
        {
            T *pt = const_cast<T *>(&u);
            return Serializer<T>(const_cast<T **>(&pt)).invoke(archive);
        }
    };

    template<typename U, typename T>
    class InvokeSerializer<U, T, Meta::Int<1> >
    {
    public:
        bool operator()(const U &u, Archive &archive)
        {
            return Serializer<T>(const_cast<T **>(&u)).invoke(archive);
        }
    };

    template<typename U, typename T>
    class InvokeSerializer<U, T, Meta::Int<2> >
    {
    public:
        bool operator()(const U &u, Archive &archive)
        {
            return Serializer<T>(const_cast<T **>(u)).invoke(archive);
        }
    };

    template<typename U>
    inline bool invokeSerializer(U u, Archive &ar) 
    {
        typedef typename GetIndirection<U>::Level Level;
        typedef typename GetIndirection<U>::Base T;
        return InvokeSerializer<U, T, Level>()(u, ar);
    }

    template<typename U>
    inline bool invokePtrSerializer(U u, Archive &ar) 
    {
        typedef typename GetIndirection<U>::Level Level;
        const int levelOfIndirection = Level::Val;
        SF_ASSERT( levelOfIndirection == 1 || levelOfIndirection == 2);
        ar.setFlag( SF::Archive::POINTER, levelOfIndirection == 2 );
        return invokeSerializer(u,ar);
    }


    template<typename Archive, typename T>
    inline void preserialize(Archive &ar, T *&pt, const unsigned int version)
    {
        serialize(ar, *pt, version);
    }

    template<typename Archive, typename T>
    inline void serialize(Archive &archive, T &t, const unsigned int version)
    {
        // defer to internal serialization
        t.serialize(archive, version);
    }
    
    template<typename Archive, typename Base, typename Derived>
    class SerializeParent 
    {
    public:
        void operator()(Archive &ar, Derived &derived)
        {
            ar & boost::serialization::base_object<Base>(derived);
        }
    };

    template<typename Base, typename Derived>
    class SerializeParent<SF::Archive, Base, Derived>
    {
    public:
        void operator()(SF::Archive &ar, Derived &derived)
        {
            SF::SerializerPolymorphic<Base,Derived>::instantiate();
            ar & SF::Archive::PARENT & static_cast<Base &>(derived);
        }
    };

}

template<typename Base, typename Archive, typename Derived>
void serializeParent(Archive &ar, Derived &derived)
{
    SF::SerializeParent<Archive, Base, Derived>()(ar, derived);
}

#endif // ! _SF_SERIALIZER_HPP_

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Jarl Lindrud

Australia Australia
Software developer, ex-resident of Sweden and now living in Canberra, Australia, working on distributed C++ applications. Jarl enjoys programming, but prefers skiing and playing table tennis. He derives immense satisfaction from referring to himself in third person.

| Advertise | Privacy | Mobile
Web03 | 2.8.141022.1 | Last Updated 6 Aug 2009
Article Copyright 2005 by Jarl Lindrud
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid