/*
* Copyright (c) 2008 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:  Implementation of DM adapter test component
* 	This is part of omadmextensions/adapter test application.
*
*/






// INCLUDE FILES

#include "TestDmDDFObject.h"
#include "StifLogger.h"

// EXTERNAL DATA STRUCTURES
//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  
//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS
//const ?type ?constant_var = ?constant;

// MACROS
//#define ?macro ?macro_def

// LOCAL CONSTANTS AND MACROS
//const ?type ?constant_var = ?constant;
//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES
//enum ?declaration
//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES
//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS
//class ?FORWARD_CLASSNAME;

// ============================= LOCAL FUNCTIONS ===============================




// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------
// CTestDmDDFObject::CTestDmDDFObject
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CTestDmDDFObject::CTestDmDDFObject( CStifLogger *aLog )
	: iName( 0 )
	, iAccessTypes()
	, iDefaultValue( 0 )
	, iDescription( 0 )
	, iFormat( (TDFFormat)0 )
	, iOccurence( (TOccurence)0 )
	, iScope( (TScope)0 )
	, iTitle ( 0 )
	, iMimeType( 0 )
	, iObjectGroup( EFalse )
	, iLog( aLog )
//	RPointerArray<CTestDmDDFObject> iChildren;
    {
    }

// -----------------------------------------------------------------------------
// CTestDmDDFObject::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CTestDmDDFObject::ConstructL()
    {
    }

// -----------------------------------------------------------------------------
// CTestDmDDFObject::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CTestDmDDFObject* CTestDmDDFObject::NewL( CStifLogger *aLog )
    {
    CTestDmDDFObject* self = CTestDmDDFObject::NewLC( aLog );
    CleanupStack::Pop( self );

    return self;
    }

CTestDmDDFObject* CTestDmDDFObject::NewLC( CStifLogger *aLog )
    {
    CTestDmDDFObject* self = new( ELeave ) CTestDmDDFObject( aLog );
    
    CleanupStack::PushL( self );
    self->ConstructL();

    return self;
    }

    
// Destructor
CTestDmDDFObject::~CTestDmDDFObject()
    {
	delete iName;
	delete iDefaultValue;
	delete iDescription;
	delete iTitle;
	delete iMimeType;
	iChildren.ResetAndDestroy();
    }


// -----------------------------------------------------------------------------
// CTestDmDDFObject::?member_function
// ?implementation_description
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
/*?type CTestDmDDFObject::?member_function(
    ?arg_type arg,
    ?arg_type arg )
    {
    
    ?code
    
    }
*/

void CTestDmDDFObject::SetAccessTypesL( TSmlDmAccessTypes aAccessTypes )
	{
	iLog->Log( _L8( "SetAccessTypesL, aAccessTypes=%d" ), aAccessTypes.GetACL() );
	iAccessTypes = aAccessTypes;
	}

void CTestDmDDFObject::SetDefaultValueL( const TDesC8& aDefaultValue )
	{
	iLog->Log( _L8( "SetDefaultValueL, aDefaultValue='%S'" ), &aDefaultValue );
	delete iDefaultValue;
	iDefaultValue = 0;
	iDefaultValue = aDefaultValue.AllocL();
	}

void CTestDmDDFObject::SetDescriptionL( const TDesC8& aDescription )
	{
	iLog->Log( _L8( "SetDescriptionL, aDescription='%S'" ), &aDescription );
	delete iDescription;
	iDescription = 0;
	iDescription = aDescription.AllocL();
	}
	
void CTestDmDDFObject::SetDFFormatL( TDFFormat aFormat )
	{
	iLog->Log( _L8( "SetDFFormatL, aFormat=%d" ), aFormat );
	iFormat = aFormat;
	}
	
void CTestDmDDFObject::SetOccurenceL( TOccurence aOccurence )
	{
	iLog->Log( _L8( "SetOccurenceL, aOccurence=%d" ), aOccurence );
	iOccurence = aOccurence;
	}
	
void CTestDmDDFObject::SetScopeL( TScope aScope )
	{
	iLog->Log( _L8( "SetScopeL, aScope=%d" ), aScope );
	iScope = aScope;
	}
	
void CTestDmDDFObject::SetDFTitleL( const TDesC8& aTitle )
	{
	iLog->Log( _L8( "SetDFTitleL, aTitle='%S'" ), &aTitle );
	delete iTitle;
	iTitle = 0;
	iTitle = aTitle.AllocL();
	}
	
void CTestDmDDFObject::AddDFTypeMimeTypeL( const TDesC8& aMimeType )
	{
	iLog->Log( _L8( "AddDFTypeMimeTypeL, aMimeType='%S'" ), &aMimeType );
	delete iMimeType;
	iMimeType = 0;
	iMimeType = aMimeType.AllocL();
	}
	
void CTestDmDDFObject::SetAsObjectGroup()
	{
	iLog->Log( _L8( "SetAsObjectGroup, true" ) );
	iObjectGroup = ETrue;
	}
	
MSmlDmDDFObject& CTestDmDDFObject::AddChildObjectL(const TDesC8& aNodeName)
	{
	iLog->Log( _L8( "AddChildObjectL, aNodeName='%S'" ), &aNodeName );
	CTestDmDDFObject* child = CTestDmDDFObject::NewLC( iLog ); //, aNodeName );
	child->SetNameL( aNodeName );
	iChildren.AppendL( child );
	CleanupStack::Pop( child ); // Don't destroy
	return *child;
	}

MSmlDmDDFObject& CTestDmDDFObject::AddChildObjectGroupL()
	{
	iLog->Log( _L8( "AddChildObjectGroupL, ''" ) );
	CTestDmDDFObject* child = CTestDmDDFObject::NewLC( iLog ); //, KNullDesC );
	child->SetAsObjectGroup();
	iChildren.AppendL( child );
	CleanupStack::Pop( child ); // Don't destroy
	return *child;
	}

// Own functions

void CTestDmDDFObject::SetNameL( const TDesC8& aName )
	{
	delete iName;
	iName = 0;
	iName = aName.AllocL();
	}

void CTestDmDDFObject::DumpL( const TDesC8& aParentName, TBool aFullDump )
	{
	TPtrC8 name( _L8("<X>") );
	if (iName && iName->Length() > 0)
		{
		name.Set( *iName );
		}

	HBufC8* fullName = HBufC8::NewLC( aParentName.Length() + name.Length() + 1 );
	*fullName = aParentName;
	if (aParentName.Length() > 0 && aParentName[ aParentName.Length() - 1 ] != '/')
		{
		fullName->Des().Append( _L8("/"));
		}
	fullName->Des().Append( name );

	/* Translate some members to text for dumping */
	TBuf8<20> strAccessTypes;
	TUint8 accessTypes = iAccessTypes.GetACL();
	if ((accessTypes & iAccessTypes.EAccessType_Add) != 0)
		{
		strAccessTypes.Append( _L8("A") );
		}
	if ((accessTypes & iAccessTypes.EAccessType_Copy) != 0)
		{
		strAccessTypes.Append( _L8("C") );
		}
	if ((accessTypes & iAccessTypes.EAccessType_Delete) != 0)
		{
		strAccessTypes.Append( _L8("D") );
		}
	if ((accessTypes & iAccessTypes.EAccessType_Exec) != 0)
		{
		strAccessTypes.Append( _L8("E") );
		}
	if ((accessTypes & iAccessTypes.EAccessType_Get) != 0)
		{
		strAccessTypes.Append( _L8("G") );
		}
	if ((accessTypes & iAccessTypes.EAccessType_Replace) != 0)
		{
		strAccessTypes.Append( _L8("R") );
		}
	
	TBuf8<20> strFormat;
	switch( iFormat )
		{
	case EB64:
		strFormat = _L8("Base64");
		break;
	case EBool:
		strFormat = _L8("Bool");
		break;
	case EChr:
		strFormat = _L8("Chr");
		break;
	case EInt:
		strFormat = _L8("Int");
		break;
	case ENode:
		strFormat = _L8("Node");
		break;
	case ENull:
		strFormat = _L8("Null");
		break;
	case EXml:
		strFormat = _L8("Xml");
		break;
	case EBin:
		strFormat = _L8("Bin");
		break;
	default:
		break;
		}


	TBuf8<20> strOccurence;
	switch( iOccurence )
		{
	case EOne:
		/** The node appears exactly once */
		strOccurence = _L8("M:1");
		break;
	case EZeroOrOne:
		/** The node is optional and may appear zero or once */
		strOccurence = _L8("O:0-1");
		break;
	case EZeroOrMore:
		/** The node is optional and may appear zero or more times */
		strOccurence = _L8("O:0-*");
		break;
	case EOneOrMore:
		/** The node is mandatory and may appear once or more times */
		strOccurence = _L8("M:1-*");
		break;
	case EZeroOrN:
		/** The node is optional and may appear between once and 'N' times */
		strOccurence = _L8("O:1-N");
		break;
	case EOneOrN:
		/** The node is mandatory and may appear between once and 'N' times */
		strOccurence = _L8("M:1-N");
		break;
	default:
		break;
		}
	
	
	TBuf8<20> strScope;
	switch( iScope)
		{
	case EPermanent:
		/** The node appears exactly once */
		strScope = _L8("Permanent");
		break;
	case EDynamic:
		/** The node is optional and may appear zero or once */
		strScope = _L8("O:Dynamic");
		break;
	default:
		break;
		}

	
	/* Dump main data */
	if (aFullDump)
		{
		iLog->Log( _L8( "DDFObject: '%S'" ), fullName );
		}
		else
		{
		iLog->Log( _L8( "DDFObject: '%S'   (%S), %S, %S, %S" ),
					fullName, &strAccessTypes, &strFormat, &strOccurence, &strScope );
		}
	
	/* Dump members */
	if (aFullDump)
		{
		TPtrC8 empty( _L8( "<null>" ) );
		#define CHK_NULL(a) ((a)==0?(TDesC8*)(&empty):(TDesC8*)(a))

		iLog->Log( _L8( "    iName=='%S'" ), iName );
		iLog->Log( _L8( "    iAccessTypes=%d (%S)" ), iAccessTypes.GetACL(), &strAccessTypes );
		iLog->Log( _L8( "    iDefaultValue='%S'" ), CHK_NULL(iDefaultValue));
		iLog->Log( _L8( "    iDescription='%S'" ), CHK_NULL(iDescription ));
		iLog->Log( _L8( "    iFormat=%d (%S)" ), iFormat, &strFormat );
		iLog->Log( _L8( "    iOccurence=%d (%S)" ), iOccurence, &strOccurence );
		iLog->Log( _L8( "    iScope=%d (%S)" ), iScope, &strScope );
		iLog->Log( _L8( "    iTitle='%S'" ), CHK_NULL(iTitle ));
		iLog->Log( _L8( "    iMimeType='%S'" ), CHK_NULL(iMimeType ));
		iLog->Log( _L8( "----------------------------------" ) );
		}
	
	/* Dump children */
	for (TInt i = 0 ; i < iChildren.Count() ; i++)
		{
		iChildren[i]->DumpL( *fullName, aFullDump );
		}

	CleanupStack::PopAndDestroy( fullName );
	}

/*
void CTestDmDDFObject::ExternalizeL(RWriteStream& aStream) const
	{
	X;
	aStream << *iName << eol;
	}
*/

const TDesC8& CTestDmDDFObject::Name()
	{
	return (iName != 0) ? *iName : KNullDesC8();
	}

TSmlDmAccessTypes  CTestDmDDFObject::AccessTypes()
	{
	return iAccessTypes;
	}

const TDesC8& CTestDmDDFObject::DefaultValue()
	{
	return (iDefaultValue != 0) ? *iDefaultValue : KNullDesC8();
	}

const TDesC8& CTestDmDDFObject::Description()
	{
	return (iDescription != 0) ? *iDescription : KNullDesC8();
	}

CTestDmDDFObject::TDFFormat CTestDmDDFObject::DFFormat()
	{
	return iFormat;
	}

CTestDmDDFObject::TOccurence CTestDmDDFObject::Occurence()
	{
	return iOccurence;
	}

CTestDmDDFObject::TScope CTestDmDDFObject::Scope()
	{
	return iScope;
	}

const TDesC8& CTestDmDDFObject::DFTitle()
	{
	return (iTitle != 0) ? *iTitle : KNullDesC8();
	}

const TDesC8& CTestDmDDFObject::DFTypeMimeType()
	{
	return (iMimeType != 0) ? *iMimeType : KNullDesC8();
	}

TBool CTestDmDDFObject::ObjectGroup()
	{
	return iObjectGroup;
	}

TInt CTestDmDDFObject::ChildObjectCount()
	{
	return iChildren.Count();
	}

CTestDmDDFObject& CTestDmDDFObject::ChildObject( TInt aIndex )
	{
	return *iChildren[aIndex];
	}

CTestDmDDFObject* CTestDmDDFObject::FindChildObject( const TDesC8& aName )
	{
	CTestDmDDFObject* foundObject = 0;

	for (TInt i = 0 ; i < iChildren.Count() ; i++)
		{
		if ( aName.CompareC( iChildren[i]->Name() ) == 0 )
			{
			foundObject = iChildren[i];
			break;
			}
		}

	return foundObject;
	}

TInt CTestDmDDFObject::SubObjectsCount()
	{
	TInt count = 0;

	TInt i;
	for (i = 0 ; i < iChildren.Count() ; i++)
		{
		count += iChildren[i]->SubObjectsCount();
		}
	count += i;

	return count;
	}

/*
// ========================== OTHER EXPORTED FUNCTIONS =========================

// -----------------------------------------------------------------------------
// ?function_name implements...
// ?implementation_description.
// Returns: ?value_1: ?description
//          ?value_n: ?description
//                    ?description
// -----------------------------------------------------------------------------
//
?type  ?function_name(
    ?arg_type arg,  // ?description
    ?arg_type arg )  // ?description
    {

    ?code

    }
*/
//  End of File