/*
* Copyright (c) 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:  ?Description
*
*/


#include <mdeobject.h>

#include <mdeproperty.h>
#include <mdeobjectdef.h>
#include <mdenamespacedef.h>
#include <mdesession.h>
#include "mdcitem.h"
#include "mdscommoninternal.h"
#include "mdcserializationbuffer.h"

//////////////////////////////
//                          //
//        TMdEObject        //
//                          //
//////////////////////////////

EXPORT_C TMdEObject::TMdEObject() : 
	iDef( NULL )
	{
	}

EXPORT_C TItemId TMdEObject::Id() const
	{
	return iId;
	}

EXPORT_C const CMdEObjectDef& TMdEObject::DefL() const
	{
	if( !iDef )
		{
		User::Leave( KErrNotFound );
		}

	return *iDef;
	}

EXPORT_C TBool TMdEObject::Confidential() const
	{
    return iFlags & EMdEObjectFlagConfidential ? ETrue : EFalse;
	}

EXPORT_C TBool TMdEObject::Placeholder() const
	{
	return iFlags & EMdEObjectFlagPlaceholder ? ETrue : EFalse;
	}

EXPORT_C TBool TMdEObject::Removed() const
	{
	return iFlags & EMdEObjectFlagRemoved ? ETrue : EFalse;
	}

EXPORT_C TBool TMdEObject::NotPresent() const
	{
	return iFlags & EMdEObjectFlagNotPresent ? ETrue : EFalse;
	}

TUint32 TMdEObject::RequiredBufferSize()
	{
	return sizeof(TMdCObject);
	}

void TMdEObject::DeSerializeL(CMdCSerializationBuffer& aBuffer, 
		CMdENamespaceDef& aNamespaceDef)
	{
	const TMdCObject& object = TMdCObject::GetFromBufferL(aBuffer);

	// ID
	if ( object.iId == KNoId )
		{
		User::Leave( KErrNotFound );
		}
	iId = object.iId;

	// definition
	if ( object.iDefId == KNoDefId )
		{
		User::Leave( KErrNotFound );
		}
	iDef = aNamespaceDef.GetObjectDefL( object.iDefId );

	// object flags	
	iFlags = object.iFlags;
	}

//////////////////////////////
//                          //
//        CMdEObject        //
//                          //
//////////////////////////////

CMdEObject* CMdEObject::NewL( CMdEObjectDef& aDef, const TDesC& aUri, TUint32 aMediaId )
	{
	CMdEObject* self = CMdEObject::NewLC( aDef, aUri, aMediaId );
    CleanupStack::Pop( self );
    return self;
	}

CMdEObject* CMdEObject::NewLC( CMdEObjectDef& aDef, const TDesC& aUri, TUint32 aMediaId )
	{
	CMdEObject* self = new ( ELeave ) CMdEObject( NULL, KNoId, aDef );
    CleanupStack::PushL( self );
    self->ConstructL( aUri, aMediaId );
    return self;
	}

CMdEObject::CMdEObject(CMdESession* aSession, TItemId aId, CMdEObjectDef& aDef)
		: CMdEInstanceItem( aSession, aId ), iDef( &aDef )
	{
	}

void CMdEObject::ConstructL( const TDesC& aUri, TUint32 aMediaId )
	{
	InstanceItemBaseConstruct();

	DoSetUriL( aUri );
	
	iMediaId = aMediaId;

    iFlags = EMdEObjectFlagModOpen;
   	}

CMdEObject::~CMdEObject()
	{
	if ( OpenForModifications() && BelongsToSession() )
		{
		TRAP_IGNORE( Session().CancelObjectL( *this ) );
		}

	delete iUri;

	iPropertyArray.ResetAndDestroy();
	iPropertyArray.Close();

	iFreeTextArray.ResetAndDestroy();
	iFreeTextArray.Close();
	}

EXPORT_C CMdEObjectDef& CMdEObject::Def() const
	{
	__ASSERT_DEBUG( iDef, User::Panic( _L("Object def is NULL!"), KErrBadHandle ) );
	
	return *iDef;
	}

EXPORT_C void CMdEObject::SetDefL(CMdEObjectDef& aDef)
	{
	__ASSERT_DEBUG( iDef, User::Panic( _L("Object def is NULL!"), KErrBadHandle ) );

	if( BelongsToSession() || ( iDef->Id() != KBaseObjectDefId ) )
		{
		User::Leave( KErrNotSupported );
		}

	iDef = &aDef;
	}

EXPORT_C const TDesC& CMdEObject::Uri() const
	{
	return *iUri;
	}

EXPORT_C void CMdEObject::SetUriL(const TDesC& aUri)
	{
	DoSetUriL(aUri);
	}

EXPORT_C TUint32 CMdEObject::MediaId() const
	{
	return iMediaId;
	}

EXPORT_C void CMdEObject::SetMediaId(TUint32 aMediaId)
	{
	iFlags |= EMdEObjectFlagModObject;
	iMediaId = aMediaId;
	}

EXPORT_C TUint32 CMdEObject::UsageCount() const
	{
	return iUsageCount;
	}

EXPORT_C void CMdEObject::Guid( TInt64& aGuidHigh, TInt64& aGuidLow ) const
	{
	aGuidHigh = iGuidHigh;
	aGuidLow  = iGuidLow;
	}
	
EXPORT_C void CMdEObject::SetGuid( const TInt64& aGuidHigh, const TInt64& aGuidLow )
	{
	iFlags |= EMdEObjectFlagModObject;
	iGuidHigh = aGuidHigh;
	iGuidLow  = aGuidLow;
	}


EXPORT_C TBool CMdEObject::Confidential() const
	{
    return iFlags & EMdEObjectFlagConfidential ? ETrue : EFalse;
	}

EXPORT_C void CMdEObject::SetConfidential( TBool aValue )
	{
	//check if no change to value
	if (Confidential() && aValue || !Confidential() && !aValue) // Confidential() == aValue
		{
		return;
		}

	if ( aValue )
		{
	    iFlags |= EMdEObjectFlagConfidential;
		}
	else
		{
	    iFlags &= ~EMdEObjectFlagConfidential;
		}
	iFlags |= EMdEObjectFlagModObject;
	}

EXPORT_C TBool CMdEObject::Placeholder() const
	{
	return iFlags & EMdEObjectFlagPlaceholder ? ETrue : EFalse;
	}

EXPORT_C void CMdEObject::SetPlaceholder( TBool aValue )
	{
	//check if no change to value
	if ( Placeholder() && aValue || !Placeholder() && !aValue) // Placeholder() == aValue
		{
		return;
		}

	if ( aValue )
		{
		iFlags |= EMdEObjectFlagPlaceholder;
		}
	else
		{
		iFlags &= ~EMdEObjectFlagPlaceholder;
		}
	iFlags |= EMdEObjectFlagModObject;
	}

void CMdEObject::DoSetUriL(const TDesC& aUri)
	{
	if ( iUri )
		{
		if ( *iUri == aUri )
			{
			return;
			}
		else
			{
			delete iUri;
			iUri = NULL;
			}
		}

	iUri = HBufC::NewL( aUri.Length() );
	// Note: CopyLC doesn't push anything to cleanup stack
	iUri->Des().CopyLC( aUri );
	iFlags |= EMdEObjectFlagModObject;
	}

EXPORT_C TInt CMdEObject::PropertyCount() const
	{
	const TInt propertyCount = iPropertyArray.Count();
	if (!(iFlags & EMdEObjectFlagModObject))
		{
		return propertyCount;
		}

	TInt c = 0;
	for (TInt i = 0; i < propertyCount; ++i)
		{
		if ( ! iPropertyArray[i]->Removed() )
			{
			++c;
			}
		}
	return c;
	}

EXPORT_C CMdEProperty& CMdEObject::PropertyL(TInt aIndex) const
	{
	if ( aIndex < 0 || aIndex > PropertyCount() )
		{
		User::Leave( KErrArgument );
		}
	if (!(iFlags & EMdEObjectFlagModObject))
		{
		return *iPropertyArray[aIndex];
		}
	
	TInt j = 0;
	const TInt count = iPropertyArray.Count();
	
	for (TInt i = 0; i < count; ++i)
		{
		if ( ! iPropertyArray[i]->Removed() )
			{
			if (j == aIndex)
				{
				return *iPropertyArray[j];
				}
			++j;
			}
		}
	User::Leave( KErrNotFound );
	return *iPropertyArray[0]; // <-- just to stop compiler warnings!!
	}

EXPORT_C TInt CMdEObject::PropertyCount(const CMdEPropertyDef& aDef) const
	{
	TInt propCount = 0;
	
	const TInt count = iPropertyArray.Count();
	
	for (TInt i = 0; i < count; i++)
		{
        if( ! iPropertyArray[i]->Removed() &&
            iPropertyArray[i]->Def().Compare( aDef ) == 0 )
        	{
        	++propCount;
        	}
		}
    return propCount;
	}

EXPORT_C TInt CMdEObject::Property(const CMdEPropertyDef& aDef, CMdEProperty*& aProperty, TInt aStartAt) const
    {
    const TInt count = iPropertyArray.Count();

    if( aStartAt >= 0 )
        {
        TInt low( aStartAt );
        TInt high( count );
    
        while( low < high )
            {
            TInt mid( (low+high)>>1 );
            
            TInt compare( aDef.Compare( iPropertyArray[mid]->Def() ) );
            if( compare == 0 )
                {
                if( !iPropertyArray[mid]->Removed() )
                    {
                    aProperty = iPropertyArray[mid];
                    return mid;
                    }
                }
            else if( compare > 0 )
                {
                low = mid + 1;
                }
            else
                {
                high = mid;
                }
            }
        }
    return KErrNotFound;
    }
    
EXPORT_C CMdEProperty& CMdEObject::AddBoolPropertyL(CMdEPropertyDef& aDef, TBool aValue)
	{
    if( aDef.PropertyType() != EPropertyBool )
    	{
    	User::Leave( KErrArgument );
    	}	
	
	CMdEProperty* property = CMdEProperty::NewLC(aDef, *this);
	property->SetBoolValueL( aValue );
	DoAddPropertyL(*property);
	CleanupStack::Pop(property);

	return *property;
	}

EXPORT_C CMdEProperty& CMdEObject::AddInt8PropertyL(CMdEPropertyDef& aDef, TInt8 aValue)
	{
    if( aDef.PropertyType() != EPropertyInt8 )
    	{
    	User::Leave( KErrArgument );
    	}	
	
    CMdEProperty* property = CMdEProperty::NewLC(aDef, *this);
    property->SetInt8ValueL( aValue );
	DoAddPropertyL(*property);
	CleanupStack::Pop(property);

	return *property;
	}

EXPORT_C CMdEProperty& CMdEObject::AddUint8PropertyL(CMdEPropertyDef& aDef, TUint8 aValue)
	{
    if( aDef.PropertyType() != EPropertyUint8 )
    	{
    	User::Leave( KErrArgument );
    	}	
	
    CMdEProperty* property = CMdEProperty::NewLC(aDef, *this);
    property->SetUint8ValueL( aValue );
	DoAddPropertyL(*property);
	CleanupStack::Pop(property);

	return *property;
	}

EXPORT_C CMdEProperty& CMdEObject::AddInt16PropertyL(CMdEPropertyDef& aDef, TInt16 aValue)
	{
    if( aDef.PropertyType() != EPropertyInt16 )
    	{
    	User::Leave( KErrArgument );
    	}	
	
    CMdEProperty* property = CMdEProperty::NewLC(aDef, *this);
    property->SetInt16ValueL( aValue );
	DoAddPropertyL(*property);
	CleanupStack::Pop(property);

	return *property;
	}

EXPORT_C CMdEProperty& CMdEObject::AddUint16PropertyL(CMdEPropertyDef& aDef, TUint16 aValue)
	{
    if( aDef.PropertyType() != EPropertyUint16 )
    	{
    	User::Leave( KErrArgument );
    	}	
	
    CMdEProperty* property = CMdEProperty::NewLC(aDef, *this);
    property->SetUint16ValueL( aValue );
	DoAddPropertyL(*property);
	CleanupStack::Pop(property);

	return *property;
	}

EXPORT_C CMdEProperty& CMdEObject::AddInt32PropertyL(CMdEPropertyDef& aDef, TInt32 aValue)
	{
    if( aDef.PropertyType() != EPropertyInt32 )
    	{
    	User::Leave( KErrArgument );
    	}	

    CMdEProperty* property = CMdEProperty::NewLC(aDef, *this);
    property->SetInt32ValueL( aValue );
	DoAddPropertyL(*property);
	CleanupStack::Pop(property);

	return *property;
	}

EXPORT_C CMdEProperty& CMdEObject::AddUint32PropertyL(CMdEPropertyDef& aDef, TUint32 aValue)
	{
    if( aDef.PropertyType() != EPropertyUint32 )
    	{
    	User::Leave( KErrArgument );
    	}	

    CMdEProperty* property = CMdEProperty::NewLC(aDef, *this);
    property->SetUint32ValueL( aValue );
	DoAddPropertyL(*property);
	CleanupStack::Pop(property);

	return *property;
	}

EXPORT_C CMdEProperty& CMdEObject::AddInt64PropertyL(CMdEPropertyDef& aDef, TInt64 aValue)
	{
    if( aDef.PropertyType() != EPropertyInt64 )
	   	{
    	User::Leave( KErrArgument );
    	}

    CMdEProperty* property = CMdEProperty::NewLC(aDef, *this);
    property->SetInt64ValueL( aValue );
	DoAddPropertyL(*property);
	CleanupStack::Pop(property);

	return *property;
	}

EXPORT_C CMdEProperty& CMdEObject::AddReal32PropertyL(CMdEPropertyDef& aDef, TReal32 aValue)
	{
    if( aDef.PropertyType() != EPropertyReal32 )
    	{
    	User::Leave( KErrArgument );
    	}

    CMdEProperty* property = CMdEProperty::NewLC(aDef, *this);
    property->SetReal32ValueL( aValue );
	DoAddPropertyL(*property);
	CleanupStack::Pop(property);

	return *property;
	}

EXPORT_C CMdEProperty& CMdEObject::AddReal64PropertyL(CMdEPropertyDef& aDef, TReal64 aValue)
	{
    if( aDef.PropertyType() != EPropertyReal64 )
    	{
    	User::Leave( KErrArgument );
    	}

    CMdEProperty* property = CMdEProperty::NewLC(aDef, *this);
    property->SetReal64ValueL( aValue );
	DoAddPropertyL(*property);
	CleanupStack::Pop(property);

	return *property;
	}

EXPORT_C CMdEProperty& CMdEObject::AddTextPropertyL(CMdEPropertyDef& aDef, const TDesC& aValue)
	{
    if( aDef.PropertyType() != EPropertyText )
    	{
    	User::Leave( KErrArgument );
    	}
	
    CMdEProperty* property = CMdEProperty::NewLC(aDef, *this);
    property->SetTextValueL( aValue );
	DoAddPropertyL(*property);
	CleanupStack::Pop(property);

	return *property;
	}

EXPORT_C CMdEProperty& CMdEObject::AddTimePropertyL(CMdEPropertyDef& aDef, TTime aValue)
	{
    if( aDef.PropertyType() != EPropertyTime )
    	{
    	User::Leave( KErrArgument );
    	}	

    CMdEProperty* property = CMdEProperty::NewLC(aDef, *this);
    property->SetTimeValueL( aValue );
	DoAddPropertyL(*property);
	CleanupStack::Pop(property);

	return *property;
	}

void CMdEObject::DoAddPropertyL(CMdEProperty& aProperty)
	{
	TInt err = iPropertyArray.InsertInOrder(&aProperty, 
								TLinearOrder<CMdEProperty>(CMdEObject::CompareProperties));
	if (err == KErrAlreadyExists)
		{
		const TInt f = iPropertyArray.FindInOrder(&aProperty,
								TLinearOrder<CMdEProperty>(CMdEObject::CompareProperties));

		// this must never happen
		__ASSERT_DEBUG( f >= KErrNone, User::Panic( _L("AddProperty find!"), KErrGeneral ) );

		if( ! iPropertyArray[f]->Removed() )
			{
			User::LeaveIfError( err );
			}

		CMdEProperty* oldProperty = iPropertyArray[f];
		iPropertyArray[f] = &aProperty;
		delete oldProperty;
		}
	else if (err < KErrNone)
		{
		User::Leave(err);
		}

	iFlags |= EMdEObjectFlagModProperty;
	}

EXPORT_C void CMdEObject::RemoveProperty(TInt aIndex)
	{
	const TInt propertyCount = iPropertyArray.Count();
	if ( aIndex < 0 || aIndex >= propertyCount )
		{
		return;
		}

	TInt j = 0;
	TBool found = EFalse;
	for (TInt i = 0; i < propertyCount; ++i)
		{
		if ( ! iPropertyArray[i]->Removed() )
			{
			if (j == aIndex)
				{
				found = ETrue;
				break;
				}
			++j;
			}
		}

	if ( !found )
		{
		return;
		}

	CMdEProperty* property = iPropertyArray[j];
	if( property->Def().ReadOnly() )
    	{
    	return;
    	}

	property->SetRemoved();

	iFlags |= EMdEObjectFlagModProperty;
	}

TInt CMdEObject::CompareProperties(const CMdEProperty& aFirst, const CMdEProperty& aSecond)
	{
	return aFirst.Def().Compare( aSecond.Def() );
	}

EXPORT_C TInt CMdEObject::FreeTextCount() const
	{
	return iFreeTextArray.Count();
	}

EXPORT_C TPtrC CMdEObject::FreeText(TInt aIndex) const
	{
	return *iFreeTextArray[aIndex];
	}

EXPORT_C TInt CMdEObject::FreeTextIndex(const TDesC& aFreeText) const
	{
	const TInt count = iFreeTextArray.Count();
	
	for (TInt i = 0; i < count; i++)
		{
		if (aFreeText.Compare(*iFreeTextArray[i]) == 0)
			{
			return i;
			}
		}

	return KErrNotFound;
	}

EXPORT_C void CMdEObject::AddFreeTextL(const TDesC& aFreeText)
	{
	HBufC* freeText = aFreeText.AllocLC();
	if (DoAddFreeTextL(*freeText) == KErrNone)
		{
		CleanupStack::Pop(freeText);
		}
	else
		{
		CleanupStack::PopAndDestroy(freeText);
		}
	}

TInt CMdEObject::DoAddFreeTextL(const HBufC& aFreeText)
	{
	TInt err = iFreeTextArray.InsertInOrder(&aFreeText, TLinearOrder<HBufC>(CMdEObject::CompareFreeTexts));

	if (err == KErrNone)
		{
		iFlags |= EMdEObjectFlagModFreeText;
		}
	return err;
	}

EXPORT_C void CMdEObject::RemoveFreeText(TInt aIndex)
	{
	delete iFreeTextArray[aIndex];
	iFreeTextArray[aIndex] = NULL;
	iFreeTextArray.Remove(aIndex);
	iFlags |= EMdEObjectFlagModFreeText;
	}

TInt CMdEObject::CompareFreeTexts(const HBufC& aFirst, const HBufC& aSecond)
	{
	return aFirst.Compare(aSecond);
	}

EXPORT_C void CMdEObject::MovePropertiesL(CMdEObject& aObject)
	{
	__ASSERT_DEBUG( iDef, User::Panic( _L("Object def is NULL!"), KErrBadHandle ) );
	
	// definitions must match
	if ( iDef->Compare( *aObject.iDef ) )
		{
		User::Leave( KErrArgument );
		}

	// object must be open
	if ( !OpenForModifications() )
		{
		User::Leave( KErrAccessDenied );
		}

	// and cannot contain any properties
	ClearObject( EFalse );
	if ( iPropertyArray.Count() )
		{
		User::Leave( KErrAlreadyExists );
		}

	const TInt arraySize = aObject.iPropertyArray.Count();
	iPropertyArray.ReserveL( arraySize );

	// add all properties to this object, 
	// but don't remove yet from other object
	for ( TInt i = 0; i < arraySize; ++i )
		{
        TInt err = iPropertyArray.InsertInOrder(aObject.iPropertyArray[i], 
                                TLinearOrder<CMdEProperty>(CMdEObject::CompareProperties));
    
        if (err == KErrAlreadyExists)
            {
            const TInt f = iPropertyArray.FindInOrder(aObject.iPropertyArray[i],
                                TLinearOrder<CMdEProperty>(CMdEObject::CompareProperties));

            if( !iPropertyArray[f]->Removed() )
                {
				continue;
                }

            CMdEProperty* oldProperty = iPropertyArray[f];
            iPropertyArray[f] = aObject.iPropertyArray[i];
            delete oldProperty;
            }
        else if (err < KErrNone)
            {
            // restore this objects to original state
            iPropertyArray.Reset();
            User::Leave(err);
            }	
		}

	// remove properties from other object
	aObject.iPropertyArray.Reset();

	// mark all moved properties as modified
	for ( TInt i = 0; i < arraySize; ++i )
		{
		CMdEProperty* property = iPropertyArray[i];
		property->SetModified();
		}

	iFlags |= EMdEObjectFlagModProperty;
	}


TBool CMdEObject::ObjectModified() const
    {
    return iFlags & EMdEObjectFlagModObject ? ETrue : EFalse;
    }

TBool CMdEObject::FreeTextModified() const
    {
    return iFlags & EMdEObjectFlagModFreeText ? ETrue : EFalse;
    }

TBool CMdEObject::PropertyModified() const
    {
    return iFlags & EMdEObjectFlagModProperty ? ETrue : EFalse;
    }

void CMdEObject::AutoLockL() const
	{
	if( BelongsToSession() )
		{
		User::Leave( KErrAlreadyExists );
		}
	
	iFlags |= EMdEObjectFlagAutoLock;
	}

EXPORT_C TBool CMdEObject::OpenForModifications() const
	{
	return iFlags & EMdEObjectFlagModOpen ? ETrue : EFalse;
	}

void CMdEObject::ClearObject( TBool aClearFlags )
	{
	// clear mod flags
	if (aClearFlags)
		{
		iFlags &= ~(EMdEObjectFlagModObject | EMdEObjectFlagModProperty | EMdEObjectFlagModFreeText | EMdEObjectFlagModOpen);

		// auto locked object's are marked back to open for modifications
		if ( iFlags & EMdEObjectFlagAutoLock )
			{
			iFlags |= EMdEObjectFlagModOpen;
			}
		}

	// clear mod flags in properties
	for (TInt i = iPropertyArray.Count() - 1; i >= 0 ; --i)
		{
    	CMdEProperty* prop = iPropertyArray[i];
        if ( prop->Removed() )
        	{
        	delete prop;
        	iPropertyArray.Remove( i );
        	continue;
        	}
        if (aClearFlags)
        	{
        	prop->ClearFlags();
        	}
		}
	}

void CMdEObject::SetNotOpenForModifications()
	{
	iFlags &= ~EMdEObjectFlagModOpen;
	}

TUint32 CMdEObject::ModifiedPropertiesCount() const
	{
	TUint32 modCount = 0;
	const TInt count = iPropertyArray.Count();
	
	for ( TInt i = 0; i < count; ++i )
		{
		if (iPropertyArray[i]->Modified())
			{
			++modCount;
			}
		}
	return modCount;
	}

TUint32 CMdEObject::RequiredBufferSize() const
	{
	TUint32 bufferSize = sizeof( TMdCObject );

	if (iUri)
		{
		bufferSize += CMdCSerializationBuffer::RequiredSize( *iUri );
		}

	TUint32 bufSave = bufferSize;
	// properties
	if ( iPropertyArray.Count() > 0 )
		{
		const TInt count = iPropertyArray.Count();
		for ( TInt i = 0; i < count; ++i )
			{
			if (iPropertyArray[i]->Modified())
				{
				bufferSize += iPropertyArray[i]->RequiredBufferSize();
				iFlags |= EMdEObjectFlagModProperty;
				}
			}
		}
	
	if (!(iFlags & EMdEObjectFlagModProperty))
		{
		bufferSize = bufSave;
		}
	
	// freetext
	if ( iFlags & EMdEObjectFlagModFreeText && iFreeTextArray.Count() > 0 )
		{
		
		const TInt count = iFreeTextArray.Count();
		for ( TInt i = 0; i < count; ++i )
			{
			bufferSize += CMdCSerializationBuffer::RequiredSize( *iFreeTextArray[i] );
			}
		}

	return bufferSize;
	}

TMdCOffset CMdEObject::SerializeL(CMdCSerializationBuffer& aBuffer, TMdCOffset aFreespaceOffset) const
	{
	__ASSERT_DEBUG( iDef, User::Panic( _L("Object def is NULL!"), KErrBadHandle ) );

	const TMdCOffset objectOffset = aBuffer.Position();
	TMdCObject object;
	
	// objectId
	object.iId = Id();
	// objectDefId
	object.iDefId = iDef->Id();
	// object flags
	object.iFlags = iFlags;
	// mediaId
	object.iMediaId = iMediaId;
	// usageCount
	object.iUsageCount = iUsageCount;
	// guid low
	object.iGuidHigh = iGuidHigh;
	// guid high
	object.iGuidLow = iGuidLow;
	// uri
	object.iUri.iPtr.iCount = iUri->Length();
	object.iUri.iPtr.iOffset = aFreespaceOffset;
	
	aBuffer.PositionL( aFreespaceOffset );
	aFreespaceOffset = aBuffer.InsertL( *iUri );

	// adding properties
	if ( iFlags & EMdEObjectFlagModProperty && iPropertyArray.Count() > 0 )
		{
		// first set up offset and count to properties
		object.iProperties.iPtr.iOffset = aFreespaceOffset;
		object.iProperties.iPtr.iCount = ModifiedPropertiesCount();

		// move after properties table
		aFreespaceOffset += object.iProperties.iPtr.iCount * sizeof( TMdCProperty );

		const TInt count = iPropertyArray.Count();
		TInt modifiedPropertyCounter = 0;
		// insert properties
		for ( TInt i = 0; i < count; ++i )
			{
			if (!iPropertyArray[i]->Modified())
				{
				continue;
				}
			aBuffer.PositionL( object.iProperties.iPtr.iOffset + modifiedPropertyCounter * sizeof( TMdCProperty ) );
			aFreespaceOffset = iPropertyArray[i]->SerializeL(aBuffer, aFreespaceOffset);
			++modifiedPropertyCounter;
			}
		}
	else
		{
		object.iProperties.iPtr.iOffset = KNoOffset;
		object.iProperties.iPtr.iCount = 0;
		}

	// adding freetext
	if ( iFlags & EMdEObjectFlagModFreeText && iFreeTextArray.Count() > 0 )
		{
		// first set up offset to freetext
		object.iFreeTexts.iPtr.iOffset = aFreespaceOffset;
		object.iFreeTexts.iPtr.iCount = iFreeTextArray.Count();

		const TInt count = iFreeTextArray.Count();
		
		// insert freetext
		aBuffer.PositionL( aFreespaceOffset );
		for ( TInt i = 0; i < count; ++i )
			{
			aFreespaceOffset = aBuffer.InsertL( *iFreeTextArray[i] );
			}
		}
	else
		{
		object.iFreeTexts.iPtr.iOffset = KNoOffset;
		object.iFreeTexts.iPtr.iCount = 0;
		}
	
	// store object informations
	aBuffer.PositionL( objectOffset );
	object.SerializeL( aBuffer );

	return aFreespaceOffset;
	}

CMdEObject* CMdEObject::NewL( CMdESession* aSession, CMdCSerializationBuffer& aBuffer, CMdENamespaceDef& aNamespaceDef )
	{
	CMdEObject* ret = CMdEObject::NewLC( aSession, aBuffer, aNamespaceDef );
	CleanupStack::Pop( ret );
	return ret;
	}


CMdEObject* CMdEObject::NewLC( CMdESession* aSession, CMdCSerializationBuffer& aBuffer, CMdENamespaceDef& aNamespaceDef )
	{
	const TMdCObject& serializedObject = TMdCObject::GetFromBufferL( aBuffer );
	
	// objectid
	if (serializedObject.iId == KNoId)
		{
		User::Leave( KErrNotFound );
		}

	// objectDefId
	if (serializedObject.iDefId == KNoDefId)
		{
		User::Leave( KErrNotFound );
		}
	CMdEObjectDef* newObjectDef = aNamespaceDef.GetObjectDefL( serializedObject.iDefId );
	if( !newObjectDef )
		{
		User::Leave( KErrNotFound );
		}

	CMdEObject* newObject = new (ELeave) CMdEObject( aSession, serializedObject.iId, *newObjectDef );
	CleanupStack::PushL( newObject );

	// set correct variables
	// object flags
	newObject->iFlags = serializedObject.iFlags;
	// mediaId
	newObject->iMediaId = serializedObject.iMediaId;
	// usage count
	newObject->iUsageCount = serializedObject.iUsageCount;
	// guid low
	newObject->iGuidHigh = serializedObject.iGuidHigh;
	// guid high
	newObject->iGuidLow = serializedObject.iGuidLow;
	// uri
	if ( serializedObject.iUri.iPtr.iCount == 0 )
		{
		User::Leave( KErrNotFound );
		}
	aBuffer.PositionL( serializedObject.iUri.iPtr.iOffset );
	newObject->iUri = aBuffer.ReceiveDes16L();

	// read properties array
	if ( serializedObject.iProperties.iPtr.iOffset != KNoOffset )
		{
		newObject->iPropertyArray.ReserveL( serializedObject.iProperties.iPtr.iCount );

		for ( TUint32 i = 0; i < serializedObject.iProperties.iPtr.iCount; ++i )
			{
			aBuffer.PositionL( serializedObject.iProperties.iPtr.iOffset
					+ i * sizeof(TMdCProperty) );

			CMdEProperty* property = CMdEProperty::NewLC( *newObject, aBuffer );
		    TInt err = newObject->iPropertyArray.InsertInOrder(property, 
		                                TLinearOrder<CMdEProperty>(CMdEObject::CompareProperties));
		    
		    if (err == KErrAlreadyExists)
		        {
		        const TInt f = newObject->iPropertyArray.FindInOrder(property,
		                                TLinearOrder<CMdEProperty>(CMdEObject::CompareProperties));

		        if( !newObject->iPropertyArray[f]->Removed() )
		            {
		            continue;
		            }

		        CMdEProperty* oldProperty = newObject->iPropertyArray[f];
		        newObject->iPropertyArray[f] = property;
		        delete oldProperty;
		        }
		    else if (err < KErrNone)
		        {
		        User::Leave(err);
		        }
			CleanupStack::Pop( property );
			}
		}

	// read freetext array
	if ( serializedObject.iFreeTexts.iPtr.iOffset != KNoOffset )
		{
		aBuffer.PositionL( serializedObject.iFreeTexts.iPtr.iOffset );

		newObject->iFreeTextArray.ReserveL( serializedObject.iFreeTexts.iPtr.iCount );
		for ( TUint32 i = 0; i < serializedObject.iFreeTexts.iPtr.iCount; ++i )
			{
			HBufC16* hbuf = aBuffer.ReceiveDes16L();
			CleanupStack::PushL( hbuf );
			newObject->iFreeTextArray.AppendL( hbuf );
			CleanupStack::Pop( hbuf );
			}
		}

	return newObject;
	}

TMdEInstanceType CMdEObject::InstanceType() const
	{
	return EMdETypeObject;
	}