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
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
#include <SF/Stream.hpp>

#include <RCF/ByteOrdering.hpp>
#include <SF/DataPtr.hpp>
#include <SF/Encoding.hpp>
#include <SF/Exception.hpp>
#include <SF/Node.hpp>
#include <SF/Tools.hpp>

#include <vector>

namespace SF {

    // ContextRead

    ContextRead::ContextRead() : 
        bEnabled_(true) 
    {}

    ContextRead::~ContextRead()
    {}

    void ContextRead::add(UInt32 nid, const ObjectId &id)
    {
        if (bEnabled_)
            nid_id_[nid] = id;
    }

    void ContextRead::add(void *ptr, const std::type_info &objType, void *pObj)
    {
        if (bEnabled_)
            type_ptr_obj_[ objType.name() ][ ptr ] = pObj;
    }

    bool ContextRead::query(UInt32 nid, ObjectId &id)
    {
        if (nid_id_.find( nid ) != nid_id_.end()) 
        {
            id = nid_id_[ nid ];
            return true;
        }
        else
            return false;
    }

    bool ContextRead::query(void *ptr, const std::type_info &objType, void *&pObj)
    {
        if ( type_ptr_obj_[ objType.name() ].find(ptr) != type_ptr_obj_[ objType.name() ].end() ) 
        {
            pObj = type_ptr_obj_[ objType.name() ][ ptr ];
            return true;
        }
        else
            return false;
    }

    void ContextRead::clear()
    { 
        nid_id_.clear(); 
        type_ptr_obj_.clear(); 
    }

    // ContextWrite

    // TODO: enable or disable by default???
    ContextWrite::ContextWrite() : 
        bEnabled_(false), 
        currentId_(1) 
    {}

    ContextWrite::~ContextWrite()
    {}

    void ContextWrite::setEnabled(bool enabled) 
    { 
        bEnabled_ = enabled; 
    }

    bool ContextWrite::getEnabled() 
    { 
        return bEnabled_; 
    }

    void ContextWrite::add(const ObjectId &id, UInt32 &nid)
    {
        if (bEnabled_) 
        {
            if (id_nid_.find( id ) != id_nid_.end())
            {
                nid = id_nid_[ id ];
            }
            else 
            {
                nid = id_nid_[ id ] = currentId_++;
            }
        }
    }
    bool ContextWrite::query(const ObjectId &id, UInt32 &nid)
    {
        if ( bEnabled_ && id_nid_.find( id ) != id_nid_.end() ) 
        {
            nid = id_nid_[ id ];
            return true;
        }
        else
        {
            return false;
        }
    }

    void ContextWrite::clear()
    { 
        id_nid_.clear();
        currentId_ = 1;
    }

    // WithContextRead

    WithContextRead::~WithContextRead()
    {}

    I_ContextRead &WithContextRead::getContext()
    {
        return context;
    }

    // WithContextWrite

    WithContextWrite::~WithContextWrite()
    {}

    I_ContextWrite &WithContextWrite::getContext()
    {
        return context;
    }

    // LocalStorage

    LocalStorage::LocalStorage() 
    {}

    LocalStorage::~LocalStorage()
    {}

    void LocalStorage::set(const std::type_info &objType, void *pObj) 
    { 
        type_ptr_[ objType.name() ] = pObj; 
    }

    void *LocalStorage::get(const std::type_info &objType)
    {
        if ( type_ptr_.find( objType.name() ) != type_ptr_.end() )
            return type_ptr_[ objType.name() ];
        else
            return NULL;
    }

    // WithLocalStorage

    WithLocalStorage::~WithLocalStorage()
    {}

    LocalStorage &WithLocalStorage::getLocalStorage() 
    { 
        return localStorage_; 
    }


    enum {
        BEGIN,
        DATA,
        END,
        BLANK
    };


    // IStream

    IStream::IStream(std::istream &is) : 
        is(is)
    {}

    bool IStream::begin(Node &node)
    {
        Byte8 byte = 0;
        read_byte(byte);
        if (byte != BEGIN) 
        {
            if (byte == BLANK) 
            {
                Byte8 count = 0;
                read_byte(count);
                std::vector<Byte8> buffer(count);
                UInt32 bytesRead = read( &(buffer[0]), count);
                if (bytesRead != static_cast<UInt32>(count)) 
                    SF_THROW(Exception, "Stream format error")(bytesRead)(count);
                return begin(node);
            }
            else 
            {
                putback_byte(byte);
                if (byte != END) 
                {
                    SF_THROW(Exception, "Stream format error")(byte);
                }
            }
        }
        else 
        {
            read_byte( byte );
            Byte8 attrSpec = byte;

            // id
            if (attrSpec & 1)
            {
                read_int(node.id);
            }

            // ref
            attrSpec = attrSpec >> 1;
            if (attrSpec & 1)
            {
                node.ref = 1;
            }

            // type
            attrSpec = attrSpec >> 1;
            if (attrSpec & 1)
            {
                UInt32 length = 0;
                read_int(length);
                node.type.allocate(length);
                read(node.type.get(), length );
            }

            // label
            attrSpec = attrSpec >> 1;
            if (attrSpec & 1)
            {
                UInt32 length = 0;
                read_int(length);
                node.label.allocate(length);
                read(node.label.get(), length);
            }

        }

        return true;
    }

    bool IStream::get(DataPtr &value)
    {
        Byte8 byte;
        read_byte( byte );
        if (byte == DATA) 
        {
            UInt32 length = 0;
            read_int(length);
            value.allocate(length);
            read(value.get(), length);
            return true;
        }
        else 
        {
            putback_byte(byte);
            return false;
        }
    }

    void IStream::end()
    {
        Byte8 byte;
        read_byte(byte);
        if (byte != END)
        {
            SF_THROW(Exception, "did not find end symbol")(byte);
        }
    }

    UInt32 IStream::read_int(UInt32 &n)
    {
        static const int nBytes = sizeof(UInt32);
        Byte8 pBytes[nBytes];
        memset(pBytes, 0, nBytes);
        UInt32 bytesRead = 0;
        bytesRead += read(pBytes, nBytes);
        RCF::networkToMachineOrder(pBytes, 4, 1);
        n = * (UInt32 *) pBytes;
        return bytesRead;
    }

    UInt32 IStream::read_byte(Byte8 &byte)
    {
        UInt32 bytesRead = 0;
        Byte8 byte_ = 0;
        bytesRead += read(&byte_, 1);
        byte = * ((Byte8 *) &byte_);
        return bytesRead;
    }

    UInt32 IStream::read(Byte8 *pBytes, UInt32 nLength)
    {
        is.read(pBytes, nLength);
        if (is.fail()) 
        {
            SF_THROW(Exception, "fail bit set on std::istream")(nLength)(is.gcount());
        }
        return is.gcount();
    }

    void IStream::putback_byte( Byte8 byte )
    {
        is.putback(byte);
    }

    // OStream

    OStream::OStream(std::ostream &os) : os(os)
    {
    }

    void OStream::begin( const Node &node )
    {
        write_byte( (Byte8) BEGIN );

        Byte8 attrSpec = 0;
        if (node.id != 0)
        {
            attrSpec |= 1<<0;
        }
        if (node.ref != 0)
        {
            attrSpec |= 1<<1;
        }
        if (node.type.get() != NULL)
        {
            attrSpec |= 1<<2;
        }
        if (node.label.get() != NULL)
        {
            attrSpec |= 1<<3;
        }

        write_byte( attrSpec );

        if (node.id != 0)
        {
            write_int(node.id);
        }
        if (node.type.get() != NULL)
        {
            write_chararray(node.type.get(), node.type.length());
        }
        if (node.label.get() != NULL)
        {
            write_chararray(node.label.get(), node.label.length() );
        }
    }

    void OStream::put(const DataPtr &value)
    {
        write_byte( (Byte8) DATA );
        write(value.get(), value.length());
    }

    void OStream::end()
    {
        write_byte( (Byte8) END );
    }

    UInt32 OStream::write_int(UInt32 n)
    {
        BOOST_STATIC_ASSERT( sizeof(n) == 4 );
        RCF::machineToNetworkOrder(&n, 4, 1);
        os.write( reinterpret_cast<char*>(&n), 4);
        if (os.fail())
        {
            SF_THROW(Exception, "fail bit set on std::ostream")(n);
        }
        return 4;
    }

    UInt32 OStream::write_byte(Byte8 byte)
    {
        os.write(&byte, 1);
        if (os.fail())
        {
            SF_THROW(Exception, "fail bit set on std::ostream");
        }
        return 1;
    }

    UInt32 OStream::write_chararray(const Char8 *pChar, UInt32 nLength)
    {
        return write(pChar, nLength);
    }

    UInt32 OStream::write(const Byte8 *pBytes, UInt32 nLength)
    {
        UInt32 bytesWritten = 0;
        bytesWritten += write_int(nLength);
        os.write(pBytes, nLength);
        if (os.fail())
        {
            SF_THROW(Exception, "fail bit set on std::ostream")(nLength);
        }
        bytesWritten += nLength;
        return bytesWritten;
    }

} // namespace SF

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)

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
Web02 | 2.8.140721.1 | Last Updated 6 Aug 2009
Article Copyright 2005 by Jarl Lindrud
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid