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); } }
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)); } }
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); } } }
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; } } } } }
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); } } }