inline void serializeFundamental(
        SF::Archive &ar, 
        T &t,
        unsigned int count = 1)
    {
        typedef typename RCF::RemoveCv<T>::type U;
        BOOST_STATIC_ASSERT( RCF::IsFundamental<U>::value );
        U * pt = const_cast<U *>(&t);

        if (ar.isRead())
        {
            I_Encoding &encoding = ar.getIstream()->getEncoding();
            DataPtr data;
            ar.getIstream()->get(data);
            if (count > 1 && count != encoding.getCount(data, pt) )
            {
                // static array size mismatch
                RCF::Exception e(RCF::_SfError_DataFormat());
                RCF_THROW(e)(typeid(U).name())(count)(encoding.getCount(data, pt));
            }
            encoding.toObject(data, pt, count);
        }
        else if (ar.isWrite())
        {
            I_Encoding &encoding = ar.getOstream()->getEncoding();
            DataPtr data;
            encoding.toData(data, pt, count );
            ar.getOstream()->put(data);
        }
    }
Beispiel #2
0
    inline void serializeString(SF::Archive & ar, std::basic_string<C,T,A> & s)
    {
        if (ar.isRead())
        {
            boost::uint32_t count = 0;
            ar & count;

            SF::IStream &is = *ar.getIstream();

            s.resize(0);

            std::size_t minSerializedLength = sizeof(C);
            if (ar.verifyAgainstArchiveSize(count*minSerializedLength))
            {
                if (count > s.capacity())
                {
                    s.reserve(count);
                }
            }

            boost::uint32_t charsRemaining = count;
            const boost::uint32_t BufferSize = 512;
            C buffer[BufferSize];
            while (charsRemaining)
            {
                boost::uint32_t charsToRead = RCF_MIN(BufferSize, charsRemaining);
                boost::uint32_t bytesToRead = charsToRead*sizeof(C);

                RCF_VERIFY(
                    is.read( (char *) buffer, bytesToRead) == bytesToRead,
                    RCF::Exception(RCF::_SfError_ReadFailure()))
                    (bytesToRead)(BufferSize)(count);

                s.append(buffer, charsToRead);
                charsRemaining -= charsToRead;
            }
        }
        else if (ar.isWrite())
        {
            boost::uint32_t count = static_cast<boost::uint32_t >(s.length());
            ar & count;
            ar.getOstream()->writeRaw(
                (char *) s.c_str(),
                count*sizeof(C));
        }

    }
Beispiel #3
0
    void serialize(SF::Archive &ar, RCF::ByteBuffer &byteBuffer)
    {
        if (ar.isRead())
        {
            boost::uint32_t len = 0;
            ar & len;

            byteBuffer.clear();

            // See if we have a remote call context.
            RCF::SerializationProtocolIn *pIn = 
                ar.getIstream()->getRemoteCallContext();

            if (pIn && len)
            {
                pIn->extractSlice(byteBuffer, len);
            }
            else if (len)
            {
                if (byteBuffer.getLength() >= len)
                {
                    byteBuffer = RCF::ByteBuffer(byteBuffer, 0, len);
                }
                else
                {
                    byteBuffer = RCF::ByteBuffer(len);
                }

                SF::IStream &is = *ar.getIstream();

                boost::uint32_t bytesToRead = len;
                boost::uint32_t bytesRead = is.read( (SF::Byte8 *) byteBuffer.getPtr(), bytesToRead);

                RCF_VERIFY(
                    bytesRead == bytesToRead,
                    RCF::Exception(RCF::_SfError_ReadFailure()))
                    (bytesToRead)(bytesRead);
            }
        }
        else if (ar.isWrite())
        {
            boost::uint32_t len = static_cast<boost::uint32_t>(byteBuffer.getLength());
            ar & len;

            // See if we have a remote call context.
            RCF::SerializationProtocolOut *pOut = 
                ar.getOstream()->getRemoteCallContext();

            if (pOut && len)
            {
                pOut->insert(byteBuffer);
            }
            else if (len)
            {
                boost::uint32_t bytesToWrite = len;
                ar.getOstream()->writeRaw(
                    (SF::Byte8 *) byteBuffer.getPtr(),
                    bytesToWrite);
            }
        }
    }
Beispiel #4
0
    void serializeVectorFastImpl(
        SF::Archive &           ar,
        I_VecWrapper &          vec)
    {
        if (ar.isRead())
        {
            boost::uint32_t count = 0;
            ar & count;

            if (count)
            {
                SF::IStream &is = *ar.getIstream();

                vec.resize(0);

                std::size_t minSerializedLength = vec.sizeofElement();
                if (ar.verifyAgainstArchiveSize(count*minSerializedLength))
                {
                    // Size field is verified, so read everything in one go.
                    vec.resize(count);

                    boost::uint32_t bytesToRead = count * vec.sizeofElement();

                    boost::uint32_t bytesActuallyRead = is.read( 
                        vec.addressOfElement(0),
                        bytesToRead);

                    RCF_VERIFY(
                        bytesActuallyRead == bytesToRead,
                        RCF::Exception(RCF::_SfError_ReadFailure()))
                        (bytesActuallyRead)(bytesToRead)(count);

                    // Byte ordering.
                    if (ar.getRuntimeVersion() >= 8)
                    {
                        RCF::networkToMachineOrder(
                            vec.addressOfElement(0), 
                            static_cast<int>(vec.sizeofElement()), 
                            static_cast<int>(vec.size()));
                    }
                }
                else
                {
                    // Size field not verified, so read in chunks.
                    boost::uint32_t elementsRemaining = count;
                    
                    while (elementsRemaining)
                    {
                        const boost::uint32_t ElementsMax = 50*1024;
                        boost::uint32_t elementsRead = count - elementsRemaining;
                        boost::uint32_t elementsToRead = RCF_MIN(ElementsMax, elementsRemaining);
                        boost::uint32_t bytesToRead = elementsToRead*vec.sizeofElement();
                        vec.resize( vec.size() + elementsToRead);

                        boost::uint32_t bytesRead = is.read( 
                            vec.addressOfElement(elementsRead), 
                            bytesToRead);

                        RCF_VERIFY(
                            bytesRead == bytesToRead,
                            RCF::Exception(RCF::_SfError_ReadFailure()))
                            (bytesRead)(bytesToRead)(ElementsMax)(count);

                        elementsRemaining -= elementsToRead;
                    }

                    // Byte ordering.
                    if (ar.getRuntimeVersion() >= 8)
                    {
                        RCF::networkToMachineOrder(
                            vec.addressOfElement(0), 
                            static_cast<int>(vec.sizeofElement()), 
                            static_cast<int>(vec.size()));
                    }
                }
            }
        }
        else if (ar.isWrite())
        {
            boost::uint32_t count = static_cast<boost::uint32_t>(vec.size());
            ar & count;
            if (count)
            {
                boost::uint32_t bytesToWrite = count * vec.sizeofElement();

                if (RCF::machineOrderEqualsNetworkOrder())
                {
                    // Don't need reordering, so write everything in one go.
                    ar.getOstream()->writeRaw( vec.addressOfElement(0), bytesToWrite);
                }
                else if (ar.getRuntimeVersion() < 8)
                {
                    // Don't need reordering, so write everything in one go.
                    ar.getOstream()->writeRaw( vec.addressOfElement(0), bytesToWrite);
                }
                else
                {
                    // Reordering needed, so we go through a temporary buffer.
                    boost::uint32_t elementsRemaining = count;
                    const boost::uint32_t BufferSize = 100*1024;

                    const boost::uint32_t ElementsMax = BufferSize / vec.sizeofElement();

                    char Buffer[BufferSize];
                    while (elementsRemaining)
                    {
                        boost::uint32_t elementsWritten = count - elementsRemaining;
                        boost::uint32_t elementsToWrite = RCF_MIN(ElementsMax, elementsRemaining);
                        boost::uint32_t bytesToWrite = elementsToWrite*vec.sizeofElement();
                        
                        memcpy( (char *) &Buffer[0], vec.addressOfElement(elementsWritten), bytesToWrite);
                        RCF::machineToNetworkOrder( &Buffer[0], vec.sizeofElement(), elementsToWrite);
                        ar.getOstream()->writeRaw( (char *) &Buffer[0], bytesToWrite);
                        elementsRemaining -= elementsToWrite;
                    }
                }
            }
        }
    }
Beispiel #5
0
    void serialize(SF::Archive &ar, RCF::ByteBuffer &byteBuffer)
    {
        RCF::SerializationProtocolIn *pIn = NULL;
        RCF::SerializationProtocolOut *pOut = NULL;

        RCF::ClientStub * pClientStub = RCF::getCurrentClientStubPtr();
        RCF::RcfSession * pRcfSession = RCF::getCurrentRcfSessionPtr();
        if (pClientStub)
        {
            pIn = &pClientStub->getSpIn();
            pOut = &pClientStub->getSpOut();
        }
        else if (pRcfSession)
        {
            pIn = &pRcfSession->getSpIn();
            pOut = &pRcfSession->getSpOut();
        }

        if (ar.isRead())
        {
            boost::uint32_t len = 0;
            ar & len;

            byteBuffer.clear();

            RCF::SerializationProtocolIn *pIn = 
                RCF::getCurrentSerializationProtocolIn();

            if (pIn && len)
            {
                pIn->extractSlice(byteBuffer, len);
            }
            else if (len)
            {
                byteBuffer = RCF::ByteBuffer(len);

                SF::IStream &is = *ar.getIstream();

                boost::uint32_t bytesToRead = len;
                boost::uint32_t bytesRead = is.read( (SF::Byte8 *) byteBuffer.getPtr(), bytesToRead);

                RCF_VERIFY(
                    bytesRead == bytesToRead,
                    RCF::Exception(RCF::_SfError_ReadFailure()))
                    (bytesToRead)(bytesRead);
            }
        }
        else if (ar.isWrite())
        {
            boost::uint32_t len = static_cast<boost::uint32_t>(byteBuffer.getLength());
            ar & len;

            RCF::SerializationProtocolOut *pOut = 
                RCF::getCurrentSerializationProtocolOut();

            if (pOut && len)
            {
                pOut->insert(byteBuffer);
            }
            else if (len)
            {
                boost::uint32_t bytesToWrite = len;
                ar.getOstream()->writeRaw(
                    (SF::Byte8 *) byteBuffer.getPtr(),
                    bytesToWrite);
            }
        }
    }