// Copyright (c) 1997-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:

// Irlan parameter data model code 

// 

//

/**

 @file

*/

#include <e32base.h>

#include "IRLANUTL.H"

#include "IRLANDAT.H"

/**

current IrLAN version 1.1

@internalComponent

*/

/*

CIrlanRegister::CIrlanRegister()

	{

	__DECLARE_NAME(_S("CIrlanRegister"));

    iParameterList.SetOffset(_FOFF(CIrlanCommand,iLink));

	iUnique=1;

	}

CIrlanRegister::~CIrlanRegister()

	{

	CIrlanCommand *cl;

	TDblQueIter<CIrlanCommand> i(iParameterList);

	while (cl=i++,cl!=NULL)

		{

		cl->iLink.Deque();	   

		delete cl;

		}

	}

CIrlanRegister *CIrlanRegister::NewL()

// Invoked to create a new instance of the IAS register object

	{

	CIrlanRegister *reg=new (ELeave) CIrlanRegister();

	reg->InitL();

	return reg;

	}

void CIrlanRegister::InitL()

// register the compulsory device classes

	{

	TIASDatabaseEntry ent;

	SetHostName(PROTEA_DEFAULT_NICKNAME);

	ent.SetClassName(IRDA_IAS_DEVICE_CLASSNAME);

	ent.SetAttributeName(IRDA_IAS_DEVICENAME_ATTR);

	ent.SetToCharString(iHostName);

	RegisterEntryL(ent);

	ent.SetClassName(IRDA_IAS_DEVICE_CLASSNAME);

	ent.SetAttributeName(IRDA_IAS_LMPSUPPORT_ATTR);

	TBuf8<3> data;

	data.SetLength(3);

	data[0]=KIrLMPVersionMask;

	data[1]=KIASSupportMask;

	data[2]=KIrLMPSupportMask;

	ent.SetToOctetSeq(data);

	RegisterEntryL(ent);

	return;

	}

void CIrlanRegister::RegisterEntryL(const TDesC8& aBuffer)

// Add a new command to the data base

	{

	TIASDatabaseEntry ent;

	ent.Copy(aBuffer);

	CIASClass * cls=LookUpCommand(ent().iClassName);

	if (cls==NULL)

		{

		TInt uniqueID=0; // "Device" is always id 0 - autoincrement for others.

		if (ent().iClassName!=IRDA_IAS_DEVICE_CLASSNAME)		

			uniqueID=iUnique++;

		cls=CIASClass::NewL(ent().iClassName,uniqueID);

		iIASClassList.AddLast(*cls);

		}

	cls->AddAttributeL(ent().iAttributeName,ent().iData);

	}

TInt CIrlanRegister::UnregisterEntry(const TDesC8& aBuffer)

//

// Remove a whole class from the database.

//

	{

	TIrlanDatabaseEntry ent;

	ent.Copy(aBuffer);

	CIASClass * cls=LookUpClass(ent().iClassName);

	if (cls==NULL)

		return KErrNotFound;

	return cls->RemoveAttribute(ent().iAttributeName);

	}

TIASQueryResult CIASRegister::Lookup(const TDesC8& aClassName,

  const TDesC8& anAttributeName,TUint16& anObjectId,TIASResponse& aResponse)

	{

	CIASClass* cls=LookUpClass(aClassName);

	if (cls!=NULL)

		{

		anObjectId=cls->LookUpObjectID();

		CIASAttribute* attr=cls->LookUpAttribute(anAttributeName);

		if (attr!=NULL)

			attr->GetAttributeData(aResponse);

		else

			return EIASNoSuchAttribute;

		}

	else

		return EIASNoSuchClass;

	return EIASSuccess;

	}

CIASClass* CIASRegister::LookUpClass(const TDesC8& aName)

//

// Go through the list of classes and see if any of them match

// on names with aName.

//

	{

	CIASClass *cl;

	TDblQueIter<CIASClass> i(iIASClassList);

	while (cl=i++,cl!=NULL)

		{

		if (cl->Match(aName))

			return cl;

		}

	return NULL;

	}

void CIASRegister::SetHostName(const TDesC8 &aName)

	{

	iHostName.Copy(aName);

	}

void CIASRegister::GetHostName(TDes8 &aName)

	{

	aName.Copy(iHostName);

	}

 */

//*******************************************************************

/**

Constructor.

*/

CIrlanParameter::CIrlanParameter()

{

	__DECLARE_NAME(_S("CIrlanParameter"));

}

/**

Destructor.

*/

CIrlanParameter::~CIrlanParameter()

{

	CIrlanParameterValue *val;

	TDblQueIter<CIrlanParameterValue> i(iIrlanParameterValueList);

	delete iParamName;

	while (val=i++,val!=NULL)

		{

		val->iLink.Deque();	

		delete val;

		}

}

/**

Invoked to create a new instance of an irlan parameter object.

@param aName parameter name.

@param aID   parameter ID.

@return A pointer to CIrlanParameter object.

*/

CIrlanParameter *CIrlanParameter::NewL(const TDesC8& aName,const TUint8 aID)

{

	CIrlanParameter *cl=new (ELeave) CIrlanParameter();

	CleanupStack::PushL(cl);

	cl->InitL(aName,aID);

	CleanupStack::Pop();

	return cl;

}

/**

We don't initialise attributes here.  Must subsequently invoke.

Add the newly created object to an parameter list.

@param aName The parameter name.

@param aCode The Command Code.

*/

void CIrlanParameter::InitL(const TDesC8& aName,TUint8 aCode)

{

	iParamName=HBufC8::NewL(aName.Length());

	TPtr8 temp=iParamName->Des();

	temp=aName;

	iCommandCode=aCode;

    iIrlanParameterValueList.SetOffset(_FOFF(CIrlanParameterValue,iLink));

}

/**

Adds the parameter value to List.

@param aName parameter name.

@param aType parameter type.

*/

void CIrlanParameter::AddParameterValueL(const TDesC8& aName,const TIrlanParameterType& aType)

{

	if (LookUpParameterValue(aName)!=NULL)

		User::Leave(KErrAlreadyExists);

	CIrlanParameterValue *val=CIrlanParameterValue::NewL(aName,aType);

	iIrlanParameterValueList.AddFirst(*val);

}

/**

Searchs a parameter in the parameter List.

@return A pointer to CIrlanParameterValue class

*/

CIrlanParameterValue* CIrlanParameter::LookUpParameterValue()

{

	CIrlanParameterValue *val=NULL;

	CIrlanParameterValue *ret=NULL;

	TDblQueIter<CIrlanParameterValue> i(iIrlanParameterValueList);

	TInt count=0;

	while (val=i++,val!=NULL)

		{

		ret=val;

		count++;

		}

	__ASSERT_DEBUG(count<=1,IrlanUtil::Fault(EIrlanInvalidParameter));

	return ret;

}

/**

Searchs a parameter in the parameter List depending on the value.

@param aValue A parameter value to be searched.

@return A pointer to CIrlanParameterValue class

*/

CIrlanParameterValue* CIrlanParameter::LookUpParameterValue(const TDesC8& aValue)

{

	CIrlanParameterValue *val;

	TDblQueIter<CIrlanParameterValue> i(iIrlanParameterValueList);

	while (val=i++,val!=NULL)

		{

		if (val->Match(aValue))

			return val;

		}

	return NULL;

}

/**

Remove the paramter value from the parameter list.

@param aValue A parameter value to be removed.

@return KErrNone if success else KErrNotFound.

*/

TInt CIrlanParameter::RemoveParameterValue(const TDesC8& aValue)

{

	CIrlanParameterValue *val=LookUpParameterValue(aValue);

	if (val==NULL)

		return KErrNotFound;

	val->iLink.Deque();

	delete val;

	if (iIrlanParameterValueList.IsEmpty())

		{

		iLink.Deque();

		delete this;

		}

	return KErrNone;

}

/**

Searches this descriptor's data for a match with the match pattern supplied in the specified 

descriptor.

@param aName A 8 bit non modifable descriptor containing the match pattern

@return If a match is found, the offset within this descriptor's data where the match first 

		occurs. 

*/

TBool CIrlanParameter::Match(const TDesC8& aName)const

{

	return (iParamName->Compare(aName)==0);

}

/**

Get the command code.

@return The command code.

*/

TUint8 CIrlanParameter::GetCommandCode()

{

	return iCommandCode;

}

//*******************************************************************

/**

Constructor.

*/

CIrlanParameterValue::CIrlanParameterValue()

{

	__DECLARE_NAME(_S("CIrlanParameter"));

}

/**

Destructor.

*/

CIrlanParameterValue::~CIrlanParameterValue()

{

	delete iParamValue;

}

/**

Invoked to create a new instance of an irlan parameter object.

@param aValue parameter value.

@param aType  parameter Type.

@return A pointer to CIrlanParameterValue object.

*/

CIrlanParameterValue* CIrlanParameterValue::NewL(const TDesC8& aValue,const TIrlanParameterType& aType)

{

	CIrlanParameterValue *val=new (ELeave) CIrlanParameterValue();

	CleanupStack::PushL(val);

	val->InitL(aValue,aType);

	CleanupStack::Pop();

	return val;

}

/**

Add the newly created object to an parameter list.

@param aValue parameter value.

@param aType  parameter Type.

*/

void CIrlanParameterValue::InitL(const TDesC8& aValue,const TIrlanParameterType& aType)

{

	iParamValue=HBufC8::NewL(aValue.Length());

	TPtr8 temp=iParamValue->Des();

	temp=aValue;

	iParamValueLength=TUint16(aValue.Length());

	iParamValueType=aType;

}

/**

Searches this descriptor's data for a match with the match pattern supplied in the specified 

descriptor.

@param aName A 8 bit non modifable descriptor containing the match pattern

@return If a match is found, the offset within this descriptor's data where the match first 

		occurs. 

*/

TBool CIrlanParameterValue::Match(const TDesC8& aName) const

{

	return (iParamValue->Compare(aName)==0);

}

/**

Gets a 8-bit integer value from the buffer.

@param aDes On completion, the 8-bit value from the buffer

*/

void CIrlanParameterValue::GetValue(TPtr8& aDes)

{

	TPtr8 val=iParamValue->Des();

	aDes.Set(val);

}

/**

Gets the length of the Parameter value.

@return The 16-bit parameter value.

*/

TUint16 CIrlanParameterValue::GetValueLength()

{

	return iParamValueLength;

}