C++ TDes8::MaxSize方法代码示例

/** 
 * Get the data from the transaction
 * 
 * Return the minimum of client buffer size and amount left to read
 */
TInt CDummyWSPCOTrans::GetData(TDes8& aBuffer, RWSPCOTrans::TDataType aDataType, TInt* aSizeLeft) const
	{	
	__ASSERT_DEBUG(aBuffer.MaxSize()>0, User::Panic(_L("Client buffer not allocated"),0));

	//const TDesC8* requestedData=*iDataArray[aDataType];
	const TDesC8* requestedData= iDataArray[aDataType];
	TInt bufferSize = aBuffer.MaxSize();
	TInt reqSize = requestedData->Size();
	TInt* offset = iOffsetArray.At(aDataType);

	TInt retSize = Min(bufferSize, (reqSize - *offset));	

	aBuffer.Zero();
	aBuffer.Append(requestedData->Mid(*offset, retSize));
	*offset += retSize;

	if (*offset==reqSize)
		{
		*aSizeLeft = 0;
		*offset = 0;
		return KErrNone;
		}
	else
		{
		*aSizeLeft = reqSize-*offset;
		return RWAPConn::EMoreData;
		}
	}

// ---------------------------------------------------------------------------
// CSensorDataCompensatorAxisDataHandler::Compensate
// ---------------------------------------------------------------------------
//
TInt CSensorDataCompensatorAxisDataHandler::Compensate( TDes8& aData )
    {
	FUNC_LOG;
	TInt err( KErrNone );
    TInt x( 0 );
    TInt y( 0 );
    TInt z( 0 );

    TRACE_MATRIX( "Axis data compensation matrix", iMatrix );

    if ( KSensrvChannelTypeIdMagnetometerXYZAxisData == iDataType )
        {
        INFO( "Compensating magnetometer data" );
        TPckgBuf<TSensrvMagnetometerAxisData> pckg;
        if ( aData.MaxSize() == pckg.MaxSize() )
            {
            pckg.Copy( aData );
            iMatrix.Transform( x, y, z, pckg().iAxisXRaw, pckg().iAxisYRaw,  pckg().iAxisZRaw );
            INFO_3( "Compensated data Magnetometer raw [X: %d], [Y: %d], [Z: %d]", x, y, z );

            pckg().iAxisXRaw = x;
            pckg().iAxisYRaw = y;
            pckg().iAxisZRaw = z;                
            iMatrix.Transform( x, y, z, pckg().iAxisXCalibrated, pckg().iAxisYCalibrated, pckg().iAxisZCalibrated );
            INFO_3( "Compensated data Magnetometer calib [X: %d], [Y: %d], [Z: %d]", x, y, z );

            pckg().iAxisXCalibrated = x;
            pckg().iAxisYCalibrated = y;
            pckg().iAxisZCalibrated = z;
            aData.Copy( pckg );    
            }
        else
            {
            err = KErrArgument;
            }
        }
    else
        {        
        INFO( "Compensating accelerometer data" );
        TPckgBuf<TSensrvAccelerometerAxisData> pckg;
        if ( aData.MaxSize() == pckg.MaxSize() )
            {
            pckg.Copy( aData );
            iMatrix.Transform( x, y, z, pckg().iAxisX, pckg().iAxisY, pckg().iAxisZ );
            INFO_3( "Compensated data accelerometer[X: %d], [Y: %d], [Z: %d]", x, y, z  );
            pckg().iAxisX = x;
            pckg().iAxisY = y;
            pckg().iAxisZ = z;
            aData.Copy( pckg );
            }
        else
            {
            err = KErrArgument;
            }
        }

    ERROR( err, "Axis data compensation error" );
    return err;
    }

/**
 * Checks that buffer size from client's message is the same
 * as position data class size specified in the class.
 *
 * @param aClass Position data class.
 * @param aBuffer Buffer containing position data class.
 * Leaves with KErrArgument if buffer is wrong.
 */
void Global::ValidatePositionClassBufferL(const TPositionClassTypeBase& aClass, const TDes8& aBuffer)
    {
DEBUG_TRACE("ValidatePositionClassBufferL in", __LINE__);
    LeaveIfFalseL(aBuffer.MaxSize() >= sizeof(TPositionClassTypeBase), KErrArgument);
    LeaveIfFalseL(aBuffer.MaxSize() >= aClass.PositionClassSize(), KErrArgument);
DEBUG_TRACE("ValidatePositionClassBufferL out", __LINE__);
    }

EXPORT_C TInt TRuntimeCtxId::Store(TDes8& aDes) const
	{
	if (Size() > aDes.MaxSize())
		{
		return KErrOverflow;
		}
	aDes.Append((TUint8*)this, Size());
	return KErrNone;
	}

	void CABDataOwnerCallbackImplementation::FillBuffer(TDes8& aDes, TBool& aFinished)
		{
		TInt bytesToAdd;
		TChar fillChar(iFillChar);
		
		if ((iOffset + aDes.MaxSize()) < iSourceSize)
			{
			aFinished = EFalse;
			bytesToAdd = aDes.MaxSize();
			}
		else
			{
			aFinished = ETrue;
			bytesToAdd = iSourceSize - iOffset;
			}

		aDes.Fill(fillChar, bytesToAdd);

		iOffset += bytesToAdd;
		}

void CDummyWSPCLConn::UnitWaitPushL(TDes8& aBody,TDes8& aHeaders,TPushID& aID,TRequestStatus& aStatus)
	{
	__ASSERT_DEBUG(aBody.MaxSize()>0, User::Panic(_L("Msg Body Buffer Not Allocated"),0));
	__ASSERT_DEBUG(aHeaders.MaxSize()>0, User::Panic(_L("Msg Header Buffer Not Allocated"),0));
	
	aStatus=KRequestPending;
	//point to the Msg Buffers
	iClientBody=&aBody;
	iClientHeaders=&aHeaders;
	iID = &aID;
	iStatus=(&aStatus);

	//Initialise Buffers to zero Before Appending 
	iClientBody->Zero();
	iClientHeaders->Zero();
	*iID =0;

	//Invoke the dummy Observer UnitWaitPush
	STATIC_CAST(CDummyWapStack* , Dll::Tls())->Observer().DWSOUnitWaitPushL(*this);
	}

// ---------------------------------------------------------------------------
// Copies descriptor from internal buffer to aData buffer.
// Size of the data to be copied is read from the buffer.
// Leaves if target descriptor cannot accept descriptor in buffer.
// ---------------------------------------------------------------------------
//
void CPosReadBufStorage::GetL( TDes8& aData ) 
  {
  TInt size;
  GetL( size );
  if ( size >= 0 && 
     aData.MaxSize() >= size &&
     iPointer + size <= iBoundary ) 
    {
    aData = TPtrC8( (TUint8*) iPointer, size );
    iPointer += size;
    }
  else
    {
    User::Leave( KErrCorrupt );
    }
  }

// -----------------------------------------------------------------------------
// RPhCltMessenger::Receive
// 
// Receive message.
// -----------------------------------------------------------------------------
//
void RPhCltMessenger::Receive(
    TRequestStatus& aStatus,
    TInt& aMessageSize,
    TDes8& aMessagePayload )
    {
    __ASSERT_ALWAYS( 
        SubSessionHandle(), User::Panic( 
            KPhClientPanicCategory, EPhCltClientSidePanicNullHandle ) );

    // Set message size variables to be byte descriptor.
    iReceiveMessageSize.Set( ( TUint8* )&aMessageSize, 0, sizeof( TInt ) ) ;
    iMessengerParameters.iReceiveMessageSizePtr = &iReceiveMessageSize;

    iMessengerParameters.iReceiveBufferMaxSize = aMessagePayload.MaxSize();

    SendReceive( 
        EPhoneServerMessengerSubSessionReceive, 
        TIpcArgs( 
            &iMesParPckg,
            &aMessagePayload,
            &iReceiveMessageSize ), 
        aStatus );
    }