diff -r 000000000000 -r 62f9d29f7211 webservices/wsutils/inc/senchunk.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/webservices/wsutils/inc/senchunk.h Thu Jan 07 16:19:19 2010 +0200 @@ -0,0 +1,490 @@ +/* +* Copyright (c) 2002-2005 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Header declaration +* +*/ + + + + + + + + + + + +#ifndef SEN_CHUNK_H +#define SEN_CHUNK_H + +// INCLUDES +#include +#include +#include + +#include +#include + +// Min size for new RChunk allocations: +const TInt KSenMinRChunkSize = 0x2750; // 10064 bytes +// Max size for new RChunk allocations: +const TInt KSenMaxRChunkSize = 0x400000; // 4194304 bytes + + +// FORWARD DECLARE +class CSenChunk; + +// CLASS DECLARATION +class TChunkHeader + /** + * This class is set in the beginning of the RChunk. Class is used + * to store header information. + * + * Note: All data in here must be 4-byte aligned (using dummy values + * if needed) + */ + { + public: + /** + * Getter for message class enumeration + * @return message type enumeration + * @see MSenMessage.h + */ + inline MSenMessage::TClass MessageType() const + { + return (MSenMessage::TClass)iMessageType; + } + + /** + * Setter for message class enumeration + * @param aValue defines the message class type enumeration. + * @see MSenMessage.h + */ + inline void SetMessageType(MSenMessage::TClass aType) + { + iMessageType = (TInt)aType; + } + + /** + * Getter for message direction enumeration + * @return message type enumeration + * @see MSenMessage.h + */ + inline MSenMessage::TDirection MessageDirection() const + { + return (MSenMessage::TDirection)iMessageDirection; + } + + /** + * Setter for message direction enumeration + * @param aValue defines the message class type enumeration. + * @see MSenMessage.h + */ + inline void SetMessageDirection(MSenMessage::TDirection aDirection) + { + iMessageDirection = (TInt)aDirection; + } + + /** + * Getter to determine should init be done before sending the message. + * @return ETrue if yes, otherwise EFalse. + */ + inline TBool DoInitBeforeSending() const + { + if ( iDoInitBeforeSending ) + { + return ETrue; + } + else + { + return EFalse; + } + } + + /** + * Sets the flag indicating that init should be done + * before sending the message + * @param aValue if ETrue, init will be done before sending + * if EFalse, init will not be done before sending + */ + inline void SetDoInitBeforeSending(TBool aValue) + { + if ( aValue ) + { + iDoInitBeforeSending = 1; + } + else + { + iDoInitBeforeSending = 0; + } +// iDoInitBeforeSending = aValue; + } + + /** + * Getter for (transport) properties type. + * @return transport properties type + * enumeration. Note: + * ENotInUse means that transport + * properties are not in use. + * @see MSenProperties + */ + inline MSenProperties::TSenPropertiesClassType PropertiesType() const + { + return (MSenProperties::TSenPropertiesClassType)iPropertiesType; + } + + /** + * Sets the (transport) properties type enumeration + * @param aType where ENotInUse indicates that + * there are no associated properties, and all + * the others point to a concrete properties + * class. + * @see MSenProperties + */ + inline void SetPropertiesType(MSenProperties::TSenPropertiesClassType aType) + { + iPropertiesType = (TInt)aType; + } + + /** + * Getter for descriptor count. + * @return the descriptor count + */ + inline TInt DescriptorCount() const + { + return iDescriptorCount; + } + + /** + * Setter for descriptor count. + * @param aCount is the descriptor count + */ + inline void SetDescriptorCount(TInt aCount) + { + iDescriptorCount = aCount; + } + + /** + * Getter for transaction id. + * @return the transaction id + */ + inline TInt TransactionId() const + { + return iTransactionId; + } + + /** + * Setter for transaction id. + * @param aID is the transaction id + */ + inline void SetTransactionId(TInt aId) + { + iTransactionId = aId; + } + + /** + * Getter for ctx id. + * @return the ctx id + */ + inline TInt ContextId() const + { + return iContextId; + } + + /** + * Setter for ctx id. + * @param aID is the ctx id + */ + inline void SetContextId(TInt aId) + { + iContextId = aId; + } + + /** + * Getter for pending transaction id. + * @return the pending transaction id + */ + inline TInt PendingTransactionId() const + { + return iPendingTransactionId; + } + + /** + * Setter for pending transaction id. + * @param aCount is the pending transaction id + */ + inline void SetPendingTransactionId(TInt aId) + { + iPendingTransactionId = aId; + } + + private: + /*MSenMessage::TClass*/ TInt iMessageType; + /*MSenMessage::TDirection*/ TInt iMessageDirection; + /*TBool*/ TInt iDoInitBeforeSending; + /*MSenProperties::TSenPropertiesClassType*/ TInt iPropertiesType; + TInt iDescriptorCount; + TInt iTransactionId; + TInt iPendingTransactionId; + TInt iContextId; + }; + +/** +* Offset to the beginning of header +*/ +const TInt KHeaderOffset = 0; + +/** +* Offset to the beginning of data +*/ +const TInt KDataOffset = KHeaderOffset + sizeof(TChunkHeader); + +// CLASS DECLARATION +class CSenChunk : public CBase + { + /** + * Helper class for storing RChunks + */ + public: + /** + * Two-phased constructor. + * @since Series60 4.0 + * @param aChunkName is the chunk name. + * @return a new CSenChunk + */ + IMPORT_C static CSenChunk* NewL(const TDesC& aChunkName); + + /** + * Two-phased constructor. + * @since Series60 4.0 + * @param aChunkName is the chunk name. + * @return a new CSenChunk + */ + IMPORT_C static CSenChunk* NewLC(const TDesC& aChunkName); + + /** + * Destructor. + */ + IMPORT_C ~CSenChunk(); + + /** + * @since Series60 4.0 + * @return a reference to internal chunk + */ + IMPORT_C RChunk& Chunk(); + + /** + * @since Series60 4.0 + * @return a pointer to ChunkName + */ + IMPORT_C TPtrC ChunkName() const; + + /** + * Creates global protected RChunk inside CSenChunk + * @since Series60 4.0 + * @return KErrNone or some system-wide Symbian error codes. + */ + IMPORT_C TInt CreateChunk(); + + /** + * Opens global protected RChunk inside CSenChunk + * @since Series60 4.0 + * @return KErrNone or some system-wide Symbian error codes. + */ + IMPORT_C TInt OpenChunk(); + + /** + * Closes RChunk inside CSenChunk + * @since Series60 4.0 + */ + IMPORT_C void CloseChunk(); + + /** + * Changes the number of bytes committed to the internal chunk. + * This value is always rounded up to the next nearest processor + * page boundary. + * This value is rounded up to KSenMinRChunkSize if value is + * less than KSenMinRChunkSize. + * @since Series60 4.0 + * @param aNewSize The number of bytes to be committed to this chunk. + * @return KErrNone or some system-wide Symbian error codes. + */ + IMPORT_C TInt AdjustChunk(TInt aNewSize); + + /** + * @since Series60 4.0 + * @return a header of the internal chunk + */ + IMPORT_C TChunkHeader& ChunkHeader(); + + /** + * Stores given descriptor into internal chunk. + * Internal chunk is tried to adjust so that given descriptor + * fits into chunk. + * @since Series60 4.0 + * @param aDesc is the descriptor to store + * @return KErrNone or some system-wide Symbian error codes. + */ + IMPORT_C TInt DescToChunk(const TDesC8& aDesc); + + /** + * Stores given descriptor into internal chunk. + * Internal chunk is tried to adjust so that given descriptor + * fits into chunk. + * @since Series60 4.0 + * @param aDesc is the descriptor to store + * @return KErrNone or some system-wide Symbian error codes. + */ + IMPORT_C TInt DescToChunk(const TDesC8& aDesc, TInt aIndex); + + /** + * Changes the number of bytes committed to the internal chunk + * and places a pointer to chunk to apAllocated. + * Size is always rounded up to the next nearest processor + * page boundary. + * Size is rounded up to KSenMinRChunkSize if given size is + * less than KSenMinRChunkSize. + * @since Series60 4.0 + * @param aSize The number of bytes to be committed to this chunk. + * @param apAllocated + * @return KErrNone or some system-wide Symbian error codes. + */ + IMPORT_C TInt AllocDescToChunk(TInt aSize, TPtr8*& apAllocated); + + /** + * Stores given descriptors into internal chunk. + * Internal chunk is tried to adjust so that both of the + * given descriptors fit into chunk. + * @since Series60 4.0 + * @param aDesc is the first descriptor to store + * @param aDesc2 is the second descriptor to store + * @return KErrNone or some system-wide Symbian error codes. + */ + IMPORT_C TInt DescsToChunk(const TDesC8& aDesc, + const TDesC8& aDesc2); + + /** + * Gets stored descriptor in given index from internal chunk. + * @since Series60 4.0 + * @param aDesc will hold the pointer to descriptor in internal chunk + * @param aIndex is the index of descriptor to get + * @return KErrNone or some system-wide Symbian error codes. + */ + IMPORT_C TInt DescFromChunk(TPtrC8& aDesc, TInt aIndex = 0); + + /** + * Gets stored descriptors from internal chunk. + * @since Series60 4.0 + * @param aDesc1 will hold the pointer to the first descriptor in internal chunk + * @param aDesc2 will hold the pointer to the second descriptor in internal chunk + * @return KErrNone or some system-wide Symbian error codes. + */ + IMPORT_C TInt DescsFromChunk(TPtrC8& aDesc1, TPtrC8& aDesc2); + + /** + * Sets an internal chunk into TIpcArgs into given po. + * @since Series60 4.0 + * @param aArgs The IPC message arguments + * @param aIndex An index value that identifies the slot in the array + * of arguments into which the chunk is to be + * placed. This must be a value in the range 0 to 3. + */ + IMPORT_C void ChunkToArgs(TIpcArgs& aArgs, TInt aIndex); + + /** + * Opens internal chunk using a handle number sent by a client to a server. + * This function is called by the server. + * @since Series60 4.0 + * @param aMessage Represents the contents of the client message + * @param aIndex An index specifying which of the four message arguments + * contains the handle number. + * @return KErrNone or some system-wide Symbian error codes. + */ + IMPORT_C TInt OpenChunkFromRMsgL(const RMessage2& aMessage, TInt aIndex); + + /** + * Opens internal chunk using a handle number returned by a server to a client. + * This function is called by the client. + * @since Series60 4.0 + * @param aHandleOrError A handle-number, if zero or positive; + * an error value, if negative. + * @return KErrNone, if aHandle is a handle-number; + * the value of aHandleOrError, otherwise.. + */ + IMPORT_C TInt OpenChunkFromHandleNumberL(TInt aHandleOrError); + + /** + * Tests whether two CSenChunks are equal. + * @since Series60 4.0 + * @param aChunk The SenChunk to be compared with this SenChunk + * @return True if the two SenChunks are equal. False if not. + */ + IMPORT_C TBool operator==(const CSenChunk& aChunk); + + /** + * Sets the file logger used for debug messages. + * @since Series60 4.0 + * @param aLog is the file logger + */ + IMPORT_C void SetLogger(RFileLogger* aLog); + + /** + * Gets the Rfile Pointer to CHUNK to send content by HTTP:POST + * @since Series60 + */ + IMPORT_C RFile& RequestFileHandle(); + + /** + * Sets the Rfile Pointer to CHUNK to send content by HTTP:POST + * @since Series60 + */ + IMPORT_C void RequestFileHandle(RFile& aFile); + + protected: // Helper functions + /** + * @since Series60 4.0 + * @return Pointer to the file logger + */ + IMPORT_C RFileLogger* Log() const; + + /** + * Constructor. + */ + IMPORT_C CSenChunk(); + + private: + /** + * This private helper ensures that cast address is dividable by four (MANDATORY in ARMv5 environment, for example) + */ + TUint8* RoundToNextDividableByFourAddress(TUint8* aValue); + + + /** + * Basic ConstructL function + * @since Series60 4.0 + * @param aChunkName is the chunk name. + */ + void ConstructL(const TDesC& aChunkName); + + + protected: // Data + HBufC* ipChunkName; + + private: // Data + RChunk iChunk; + RFileLogger* iLog; + RFile iFile; + }; + +#endif //R_SEN_SERVICE_CONNECTION_H