void AsioSessionState::read(
const ByteBuffer &byteBuffer,
std::size_t bytesRequested)
{
RCF2_TRACE("")(this);
if (byteBuffer.getLength() == 0)
{
std::vector<char> &vec = getUniqueReadBufferSecondary();
vec.resize(bytesRequested);
mTempByteBuffer = getReadByteBufferSecondary();
}
else
{
mTempByteBuffer = ByteBuffer(byteBuffer, 0, bytesRequested);
}
RCF_ASSERT(
bytesRequested <= mTempByteBuffer.getLength())
(bytesRequested)(mTempByteBuffer.getLength());
char *buffer = mTempByteBuffer.getPtr();
std::size_t bufferLen = mTempByteBuffer.getLength();
Lock lock(mMutex);
if (!mHasBeenClosed)
{
implRead(buffer, bufferLen);
}
}
void AsioSessionState::read(
const ByteBuffer &byteBuffer,
std::size_t bytesRequested)
{
if (byteBuffer.getLength() == 0 && bytesRequested > 0)
{
if (!mNetworkReadBufferPtr || mNetworkReadBufferPtr.unique())
{
mNetworkReadBufferPtr = getObjectPool().getReallocBufferPtr();
}
mNetworkReadBufferPtr->resize(bytesRequested);
mNetworkReadByteBuffer = ByteBuffer(mNetworkReadBufferPtr);
}
else
{
mNetworkReadByteBuffer = ByteBuffer(byteBuffer, 0, bytesRequested);
}
RCF_ASSERT_LTEQ(bytesRequested, mNetworkReadByteBuffer.getLength());
char *buffer = mNetworkReadByteBuffer.getPtr();
std::size_t bufferLen = mNetworkReadByteBuffer.getLength();
Lock lock(mSessionPtr->mDisableIoMutex);
if (!mSessionPtr->mDisableIo)
{
if (mSocketOpsMutexPtr)
{
Lock lock(*mSocketOpsMutexPtr);
implRead(buffer, bufferLen);
}
else
{
implRead(buffer, bufferLen);
}
}
}
void AsioSessionState::onReflectedReadWriteCompleted(
const AsioErrorCode & error,
size_t bytesTransferred)
{
RCF_UNUSED_VARIABLE(error);
RCF_ASSERT(
mState == ReadingData ||
mState == ReadingDataCount ||
mState == WritingData)
(mState);
RCF_ASSERT(mReflecting);
if (bytesTransferred == 0)
{
// Previous operation was aborted for some reason (probably because
// of a thread exiting). Reissue the operation.
mState = (mState == WritingData) ? ReadingData : WritingData;
}
if (mState == WritingData)
{
mState = ReadingData;
ReallocBuffer & readBuffer = *mAppReadBufferPtr;
readBuffer.resize(8*1024);
char *buffer = &readBuffer[0];
std::size_t bufferLen = readBuffer.size();
Lock lock(mSessionPtr->mDisableIoMutex);
if (!mSessionPtr->mDisableIo)
{
if (mSocketOpsMutexPtr)
{
Lock lock(*mSocketOpsMutexPtr);
implRead(buffer, bufferLen);
}
else
{
implRead(buffer, bufferLen);
}
}
}
else if (
mState == ReadingData ||
mState == ReadingDataCount)
{
mState = WritingData;
ReallocBuffer & readBuffer = *mAppReadBufferPtr;
char *buffer = &readBuffer[0];
std::size_t bufferLen = bytesTransferred;
// mReflecteePtr will be nulled in onWriteCompletion(), otherwise
// we could easily end up with a cycle
RCF_ASSERT(!mReflecteePtr);
mReflecteePtr = mReflecteeWeakPtr.lock();
if (mReflecteePtr)
{
RCF_ASSERT(mReflecteePtr->mReflecting);
Lock lock(mReflecteePtr->mSessionPtr->mDisableIoMutex);
if (!mReflecteePtr->mSessionPtr->mDisableIo)
{
// TODO: if this can throw, then we need a scope_guard
// to reset mReflecteePtr
if (mReflecteePtr->mSocketOpsMutexPtr)
{
Lock lock(*mReflecteePtr->mSocketOpsMutexPtr);
mReflecteePtr->implWrite(*this, buffer, bufferLen);
}
else
{
mReflecteePtr->implWrite(*this, buffer, bufferLen);
}
}
}
}
}
void AsioSessionState::onReflectedReadWrite(
const boost::system::error_code& error,
size_t bytesTransferred)
{
RCF2_TRACE("")(this);
RCF_UNUSED_VARIABLE(error);
RCF_ASSERT(
mState == ReadingData ||
mState == ReadingDataCount ||
mState == WritingData)
(mState);
RCF_ASSERT(mReflecting);
if (bytesTransferred == 0)
{
// Previous operation was aborted for some reason (probably because
// of a thread exiting). Reissue the operation.
mState = (mState == WritingData) ? ReadingData : WritingData;
}
if (mState == WritingData)
{
mState = ReadingData;
std::vector<char> &readBuffer = getReadBuffer();
readBuffer.resize(8*1024);
char *buffer = &readBuffer[0];
std::size_t bufferLen = readBuffer.size();
Lock lock(mMutex);
if (!mHasBeenClosed)
{
implRead(buffer, bufferLen);
}
}
else if (
mState == ReadingData ||
mState == ReadingDataCount)
{
mState = WritingData;
std::vector<char> &readBuffer = getReadBuffer();
char *buffer = &readBuffer[0];
std::size_t bufferLen = bytesTransferred;
// mReflecteePtr will be nulled in onWriteCompletion(), otherwise
// we could easily end up with a cycle
RCF_ASSERT(!mReflecteePtr);
mReflecteePtr = mReflecteeWeakPtr.lock();
if (mReflecteePtr)
{
RCF_ASSERT(mReflecteePtr->mReflecting);
Lock lock(mReflecteePtr->mMutex);
if (!mReflecteePtr->mHasBeenClosed)
{
// TODO: if this can throw, then we need a scope_guard
// to reset mReflecteePtr
mReflecteePtr->implWrite(*this, buffer, bufferLen);
}
}
}
}
