/*

* 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)

	{

	}

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 );

    	}