diff -r 000000000000 -r 8e480a14352b messagingfw/msgsrvnstore/server/src/CMsvAttachment.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/messagingfw/msgsrvnstore/server/src/CMsvAttachment.cpp	Mon Jan 18 20:36:02 2010 +0200
@@ -0,0 +1,490 @@
+// Copyright (c) 2004-2009 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:
+//
+
+#include <cmsvattachment.h>
+#include "CMsvAttributeManager.h"
+
+const TInt KMsvAttachmentVersion = 2; // version number used for streaming
+
+/**
+Standard 2-phase construction, creates the attachment object.
+
+The object should then be initialised with information about the attachment.
+
+@param aType The attachment type.
+@return Pointer to the created attachment object.
+*/
+EXPORT_C CMsvAttachment* CMsvAttachment::NewL(TMsvAttachmentType aType)
+	{
+	CMsvAttachment* self = new(ELeave) CMsvAttachment(aType);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+/**
+Standard 2-phase construction, creates the attachment object. 
+
+The object should then be initialised with information about the attachment. This allows
+the caller to pass in commonly used attributes to initialise them on construction to
+save the caller from having to call the relavant Set... methods. The attributes that can
+be initialised are Mime-Type, attachment name and size. Callers should pass in NULL for
+any attributes that are not required to be set.
+
+@param aType The attachment type.
+@param aSize The size of the attachment. For file attachments this should be the file
+	   		 size and for message entry attachments this should be the message size.
+@param aMimeType The Mime-Type of the attachment.
+@param aAttachmentName The attachment name to identify the attachment.
+@return Pointer to the created attachment object.
+*/
+EXPORT_C CMsvAttachment* CMsvAttachment::NewL(TMsvAttachmentType aType, TInt aSize, HBufC8* aMimeType, HBufC* aAttachmentName)
+	{
+	CMsvAttachment* self = new(ELeave) CMsvAttachment(aType, aSize, aMimeType, aAttachmentName);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+EXPORT_C CMsvAttachment* CMsvAttachment::NewL(const CMsvAttachment& aAttachment)
+	{
+	CMsvAttachment* self = new(ELeave) CMsvAttachment(aAttachment.iType);
+	CleanupStack::PushL(self);
+	self->ConstructL(aAttachment);
+	CleanupStack::Pop(self);
+	return self;
+	}
+	
+CMsvAttachment::CMsvAttachment(TMsvAttachmentType aType)
+	: iType(aType)
+	{
+	}	
+
+CMsvAttachment::CMsvAttachment(TMsvAttachmentType aType, TInt aSize, HBufC8* aMimeType, HBufC* aAttachmentName)
+	: iType(aType), iSize(aSize), iMimeType(aMimeType), iAttachmentName(aAttachmentName)
+	{
+	}
+
+void CMsvAttachment::ConstructL()
+	{
+	iAttributeManager = CMsvAttributeManager::NewL(*this);
+	}
+
+void CMsvAttachment::ConstructL(const CMsvAttachment& aAttachment)
+	{
+	ConstructL();
+	
+	// Creates a deep copy of the attachment object passed in
+	iId = aAttachment.iId;
+	iSize = aAttachment.iSize;
+	if( aAttachment.iMimeType != NULL )
+		iMimeType = aAttachment.iMimeType->AllocL();
+	if( aAttachment.iFilePath != NULL )
+		iFilePath = aAttachment.iFilePath->AllocL();
+	iEntryId = aAttachment.iEntryId;
+	if( aAttachment.iAttachmentName != NULL )
+		iAttachmentName = aAttachment.iAttachmentName->AllocL();
+	iComplete = aAttachment.iComplete;
+	
+	// Create a copy of the attribute manager
+	iAttributeManager->CloneL(*aAttachment.iAttributeManager);
+	}
+
+/**
+Standard destructor.
+*/
+EXPORT_C CMsvAttachment::~CMsvAttachment()
+	{
+	delete iAttributeManager;
+	delete iMimeType;
+	delete iFilePath;
+	delete iAttachmentName;
+	}
+
+/**
+Returns the attachment Id.
+
+The attachment Id is unique on a per message entry basis.
+
+@return The attachment Id.
+*/
+EXPORT_C TMsvAttachmentId CMsvAttachment::Id() const
+	{
+	return iId;
+	}
+	
+/**
+Sets the attachment Id.
+
+The attachment Id is automatically set when passed to the Attachment Manager. This
+method allows the Id to be over-ridden or set by different implementations of
+attachment managers.
+@param aId The attachment Id to set.
+*/
+EXPORT_C void CMsvAttachment::SetId(TMsvAttachmentId aId)
+	{
+	iId = aId;
+	}
+
+/**
+Returns the attachment type.
+
+The attachment types can be a file, a linked file or a message entry attachment.
+
+@return The attachment type.
+@see TMsvAttachmentType
+*/
+EXPORT_C CMsvAttachment::TMsvAttachmentType CMsvAttachment::Type() const
+	{
+	return iType;
+	}
+
+/**
+Returns the message entry Id for message entry attachment. This is only valid if the attachment
+type is EMessageEntry.
+@return The message entry Id for the entry attachment.
+*/
+EXPORT_C TMsvId CMsvAttachment::EntryAttachmentId() const
+	{
+	__ASSERT_DEBUG(iType==EMsvMessageEntry, User::Invariant());
+	
+	return iEntryId;
+	}
+	
+void CMsvAttachment::SetEntryAttachmentId(TMsvId aEntryId)
+	{
+	iEntryId = aEntryId;
+	}
+
+/**
+Returns the attachment name.
+
+The attachment name is a readable text attribute to identify the attachment.
+
+@return Descriptor containing attachment name. Zero-length descriptor if attachment 
+		name is not set. 
+*/	
+EXPORT_C const TDesC& CMsvAttachment::AttachmentName() const
+	{
+	if( iAttachmentName==NULL )
+		return KNullDesC();
+	
+	return *iAttachmentName;
+	}
+	
+/*
+Sets the attachment name.
+
+The attachment name is a readable text attribute to identify the attachment.
+
+For example, this might be set as the filename for file based attachemnts.
+@param aAttachmentName Descriptor containing the attachment name.
+*/
+EXPORT_C void CMsvAttachment::SetAttachmentNameL(const TDesC& aAttachmentName)
+	{
+	delete iAttachmentName;
+	iAttachmentName = NULL;
+	iAttachmentName = aAttachmentName.AllocL();
+	}
+
+/**
+Returns the full path specification for file attachments.
+
+This is only valid for file attachments where the attachment type is EMsvFile
+or EMsvLinkedFile.
+
+@return Descriptor containing full file path of the file attachment.
+*/	
+EXPORT_C const TDesC& CMsvAttachment::FilePath() const
+	{
+	__ASSERT_ALWAYS(iType!=EMsvMessageEntry, User::Invariant());
+	
+	if (iFilePath!=NULL)
+		return *iFilePath;
+	else
+		return KNullDesC;
+	}
+	
+void CMsvAttachment::SetFilePathL(const TDesC& aFilePath)
+	{
+	__ASSERT_DEBUG(iType!=EMsvMessageEntry, User::Invariant());
+	
+	HBufC* newFilePath = aFilePath.AllocL();
+	delete iFilePath;
+	iFilePath = NULL;
+	iFilePath = newFilePath;
+	iNeedsPath = EFalse;
+	}
+	
+/**
+Size of the attachment.
+
+Return the size of the attachment in bytes.
+
+@return The size of the attachment.
+*/
+EXPORT_C TInt CMsvAttachment::Size() const
+	{
+	return iSize;
+	}
+
+/**
+Sets the attachment size.
+
+When initialising or updating the attachment, this method should be used to set
+the size in bytes.
+
+@param aSize The size of the attachment in bytes.
+*/
+EXPORT_C void CMsvAttachment::SetSize(TInt aSize)
+	{
+	iSize = aSize;
+	}
+
+/**
+The mime-type of the attachment.
+
+@return Descriptor containing mime-type. Zero-length descriptor if mime-type is not set.
+*/
+EXPORT_C const TDesC8& CMsvAttachment::MimeType() const
+	{	
+	if(iMimeType==NULL)
+		return KNullDesC8();
+	
+	return *iMimeType;
+	}
+
+/**
+Sets the mime-type of the attachment.
+
+@param aMimeType Descriptor containing the mime-type.	
+*/
+EXPORT_C void CMsvAttachment::SetMimeTypeL(const TDesC8& aMimeType)
+	{
+	delete iMimeType;
+	iMimeType = NULL;
+	iMimeType = aMimeType.AllocL();
+	}
+
+void CMsvAttachment::ExternalizeL(RWriteStream& aStream) const
+	{
+	// Stream out attachment....
+	
+	// 1. Start with version - TInt
+	aStream.WriteInt32L(KMsvAttachmentVersion);
+	
+	// 2. attachment id - TUint
+	aStream.WriteUint32L(iId);
+	
+	// 3. attachment type - TInt (enum)
+	aStream.WriteInt32L(iType);
+	
+	// 4. attachment size - TInt
+	aStream.WriteInt32L(iSize);
+	
+	// 5. mime-type - HBufC8
+	aStream << MimeType();
+			
+	// 6. message entry id - TInt (TMsvId)
+	aStream.WriteInt32L(iEntryId);
+	
+	// 7. file path - HBufC (if not message entry)
+	if(	iType != EMsvMessageEntry )
+		{
+		// Only stream out the filename for file attachments
+		if( iType == EMsvFile )
+			{
+			TParsePtrC filePath(FilePath());
+			aStream << filePath.NameAndExt();
+			}
+		else
+			{
+			// must be linked file, stream whole path
+			aStream << FilePath();
+			}
+		}
+	
+	// 8. attachment name - HBufC
+	aStream << AttachmentName();
+	
+	// 9. complete flag - TInt (TBool)
+	aStream.WriteInt32L(iComplete);
+	
+	// 10. the attributes (CMsvAttributeManager)
+	aStream << *iAttributeManager;
+	}
+
+void CMsvAttachment::InternalizeL(RReadStream& aStream)
+	{
+	// Stream in attachment info and populate data members...
+	// 1. Start with version - TInt
+	TInt version = aStream.ReadUint32L();
+	if( version>KMsvAttachmentVersion )
+		{
+		User::Leave(KErrNotSupported);
+		}
+	else
+		{
+		// 2. attachment id - TUint
+		iId = aStream.ReadUint32L();
+		
+		// 3. attachment type - TInt (enum)
+		iType = static_cast<TMsvAttachmentType>(aStream.ReadInt32L());
+		
+		// 4. attachment size - TInt
+		iSize = aStream.ReadInt32L();
+		
+		// 5. mime-type - HBufC8
+		iMimeType = HBufC8::NewL(aStream, KMaxTInt);
+				
+		// 6. message entry id - TInt (TMsvId)
+		iEntryId = aStream.ReadInt32L();
+		
+		// Versioning is required for file path, v1 simply stores the
+		// whole file path but v2 only stores the file name for EMsvFile
+		// types and requires that the attachment manager sets the path
+		// dynamically.		
+		if(	iType != EMsvMessageEntry )
+			{
+			// 7. file path - HBufC (if not message entry)
+			iFilePath = HBufC::NewL(aStream, KMaxTInt);
+			if( version==KMsvAttachmentVersion && iType==EMsvFile )
+				{
+				// Flag that the path still needs to be dynamically set
+				iNeedsPath = ETrue;
+				}
+			}
+		
+		// 8. attachment name - HBufC
+		iAttachmentName = HBufC::NewL(aStream, KMaxTInt);
+		
+		// 9. complete flag - TInt (TBool)
+		iComplete = aStream.ReadInt32L();
+		
+		// 10. the attributes (CMsvAttributeManager)
+		aStream >> *iAttributeManager;
+		}
+	}
+
+/**
+Indicates whether attachment is complete or not.
+
+This allows support for incomplete or pending attachments.
+
+@return ETrue if the attachment is complete, EFalse otherwise.
+*/
+EXPORT_C TBool CMsvAttachment::Complete() const
+	{
+	return iComplete;
+	}
+
+/**
+Sets whether the attachment is complete or not.
+
+This allows support for incomplete or pending attachments.
+
+@param aComplete ETrue if the attachment is complete, EFalse otherwise.
+*/
+EXPORT_C void CMsvAttachment::SetComplete(TBool aComplete)
+	{
+	iComplete = aComplete;
+	}
+
+/**
+Sets an 8-bit descriptor attribute for the attachment.
+
+A UID identifier uniquely identifies the attribute. If an attibute already exists with the same
+identifier, the old attribute is over-written.
+
+This can be used to store an attribute as an 8-bit descriptor or binary data.
+@param aAttributeId The unique identifier for the attribute.
+@param aAttribute The attribute data to store. The descriptor is copied internally.
+*/
+EXPORT_C void CMsvAttachment::SetDesC8AttributeL(TUid aAttributeId, const TDesC8& aAttribute)
+	{
+	iAttributeManager->SetDesC8AttributeL(aAttributeId, aAttribute);
+	}
+
+/**
+Gets an 8-bit descriptor attribute.
+
+Gets the attribute uniquely identified by the UID identifer set using the SetDesC8AttributeL
+method.
+@param aAttributeId The unique identifier for the attribute.
+@param aAttribute If attribute is found, this will be set to point to the attribute data.
+@return KErrNone is successful, KErrNotFound if the attribute cannot be found.
+*/	
+EXPORT_C TInt CMsvAttachment::GetDesC8Attribute(TUid aAttributeId, TPtrC8& aAttribute) const
+	{
+	return iAttributeManager->GetDesC8Attribute(aAttributeId, aAttribute);
+	}
+
+/**
+Removes an 8-bit descriptor attribute.
+
+Removes the attribute identified by its UID identifer. This methods has no effect if the
+attribute does not exist.
+@param aAttributeId The unique identifier for the attribute.
+*/
+EXPORT_C void CMsvAttachment::RemoveDesC8Attribute(TUid aAttributeId)
+	{
+	iAttributeManager->RemoveDesC8Attribute(aAttributeId);
+	}
+
+/**
+Sets an integer attribute for the attachment.
+
+A UID identifier uniquely identifies the attribute. If an attibute already exists with the same
+identifier, the old attribute is over-written.
+@param aAttributeId The unique identifier for the attribute.
+@param aAttribute The attribute data to store.
+*/
+EXPORT_C void CMsvAttachment::SetIntAttributeL(TUid aAttributeId, TInt aAttribute)
+	{
+	iAttributeManager->SetIntAttributeL(aAttributeId, aAttribute);
+	}
+
+/**
+Gets an integer attribute.
+
+Gets the attribute uniquely identified by the UID identifer set using the SetIntAttributeL method.
+@param aAttributeId The unique identifier for the attribute.
+@param aAttribute If attribute is found, this will be set to the attribute data.
+@return KErrNone is successful, KErrNotFound if the attribute cannot be found.
+*/	
+EXPORT_C TInt CMsvAttachment::GetIntAttribute(TUid aAttributeId, TInt& aAttribute) const
+	{
+	return iAttributeManager->GetIntAttribute(aAttributeId, aAttribute);
+	}
+
+/**
+Removes an integer attribute.
+
+Removes the attribute identified by its UID identifer. This methods has no effect if the
+attribute does not exist.
+@param aAttributeId The unique identifier for the attribute.
+*/	
+EXPORT_C void CMsvAttachment::RemoveIntAttribute(TUid aAttributeId)
+	{
+	iAttributeManager->RemoveIntAttribute(aAttributeId);
+	}
+	
+TBool CMsvAttachment::IsPathRequired() const
+	{
+	return iNeedsPath;
+	}
+