/*

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

*

*/

CMDnsParamSetBase* CMDnsParamSetBase::NewL ( RParameterFamily& aFamily, TMDnsParamSetFamily aFamilyType )

	{

	STypeId typeId;

	typeId = STypeId::CreateSTypeId( KMDnsParamsFactoryUid, aFamilyType );

	CMDnsParamSetBase* self = static_cast < CMDnsParamSetBase* > ( CSubConParameterSet::NewL( typeId ) );

	TBool containerValue = aFamily.IsNull();

	if(!containerValue)

		{

		CleanupStack::PushL ( self );

		aFamily.AddParameterSetL ( self, RParameterFamily::ERequested );			

		CleanupStack::Pop ( self );

		}

	return self;	

	}

CMDnsParamSetBase::CMDnsParamSetBase ()

	{

	}

// ------------------------------------------

CMDnsQueryRequestParamSet* CMDnsQueryRequestParamSet::NewL ( RParameterFamily& aFamily )

 	{	 

 	return static_cast < CMDnsQueryRequestParamSet* > ( CMDnsParamSetBase::NewL( aFamily, EMDnsDiscoverRequestParamSet ) );

 	}

void CMDnsQueryRequestParamSet::SetInstanceNameL ( const TDesC8& aName )

	{

	iInstanceName.Close ();

	iInstanceName.CreateL(aName);

	}

const TDesC8& CMDnsQueryRequestParamSet::InstanceName () const

	{

	return iInstanceName;

	}

void CMDnsQueryRequestParamSet::SetQueryTypeL(TInt aQueryType)

	{

	iQueryType = aQueryType;

	}

TInt CMDnsQueryRequestParamSet::QueryType()const

	{

	return iQueryType;

	}	

void CMDnsQueryRequestParamSet::SetProtocol(TInt aProtocol)

	{

	iProtocol = aProtocol;

	}

TInt CMDnsQueryRequestParamSet::Protocol() const

	{

	return iProtocol;

	}

void CMDnsQueryRequestParamSet::SetServiceTypeL(const TDesC8& aServiceType)

	{

	iServiceType.Close();

	iServiceType.CreateL(aServiceType);

	}	

const TDesC8& CMDnsQueryRequestParamSet::ServiceType()const

	{

	return iServiceType;

	}	

CMDnsQueryRequestParamSet::~CMDnsQueryRequestParamSet ()

	{

	iInstanceName.Close ();

	iServiceType.Close ();

	}

// -------------------------------------------------------------------------

CMDnsPtrParamSet* CMDnsPtrParamSet::NewL(RParameterFamily& aFamily)	

	{

	return static_cast < CMDnsPtrParamSet* > ( CMDnsParamSetBase::NewL( aFamily, EMdnsPtrParamset ) );	

	}

void CMDnsPtrParamSet::SetInstanceNameL(const TDesC8& aName)

	{

	iInstanceName.Close ();

	iInstanceName.CreateL(aName);	

	}

const TDesC8& CMDnsPtrParamSet::InstanceName()const

	{

	return iInstanceName;	

	}

void CMDnsPtrParamSet::SetDomainNameL(const TDesC8& aDomainName)

	{

	iDomainName.Close ();

	iDomainName.CreateL(aDomainName);	

	}

const TDesC8& CMDnsPtrParamSet::DomainName() const

	{

	return iDomainName;	

	}

void CMDnsPtrParamSet::SetTtlL(TInt aTtl)

    {

    iTtl = aTtl;

    }

TInt CMDnsPtrParamSet::Ttl() const

    {

    return iTtl;

    }

CMDnsPtrParamSet::~CMDnsPtrParamSet()

	{

	iInstanceName.Close();

	iDomainName.Close();

	}

//----------------------------------------------------------------------------------------	

CMDnsSrvParamSet* CMDnsSrvParamSet::NewL(RParameterFamily& aFamily)	

	{

	return static_cast < CMDnsSrvParamSet* > ( CMDnsParamSetBase::NewL( aFamily, EMdnsSrvParamset ) );	

	}

void CMDnsSrvParamSet::SetDomainNameL(const TDesC8& aDomainName)

	{

	iDomainName.Close ();

	iDomainName.CreateL(aDomainName);	

	}

const TDesC8& CMDnsSrvParamSet::DomainName() const

	{

	return iDomainName;	

	}

void CMDnsSrvParamSet::SetTargetL(const TDesC8& aTarget)

	{

	iTarget.Close ();

	iTarget.CreateL(aTarget);	

	}

const TDesC8& CMDnsSrvParamSet::Target() const

	{

	return iTarget;	

	}	

void CMDnsSrvParamSet::SetPriority(TUint16 aPriority)

	{

	iPrio = aPriority;

	}

TUint16 CMDnsSrvParamSet::Priority()const

	{

	return iPrio;

	}

void CMDnsSrvParamSet::SetWeight(TUint16 aWeight)

	{

	iWeight = aWeight;

	}

TUint16 CMDnsSrvParamSet::Weight()const

	{

	return iWeight;

	}

void CMDnsSrvParamSet::SetPort(TUint16 aPort)

	{

	iPort = aPort;

	}

TUint16 CMDnsSrvParamSet::Port()const

	{

	return iPort;

	}

CMDnsSrvParamSet::~CMDnsSrvParamSet()

	{

	iTarget.Close();

	iDomainName.Close();

	}	

//--------------------------------------------------------------------------------

CMDnsAddrParamSet* CMDnsAddrParamSet::NewL(RParameterFamily& aFamily)	

	{

	return static_cast < CMDnsAddrParamSet* > ( CMDnsParamSetBase::NewL( aFamily, EMdnsAddrParamset ) );	

	}

void CMDnsAddrParamSet::SetDomainNameL(const TDesC8& aDomainName)

	{

	iDomainName.Close ();

	iDomainName.CreateL(aDomainName);	

	}

const TDesC8& CMDnsAddrParamSet::DomainName() const

	{

	return iDomainName;	

	}

void CMDnsAddrParamSet::SetAddress(TInetAddr aAddr)

	{

	iAddr = aAddr;

	}

TInetAddr CMDnsAddrParamSet::Address()const

	{

	return iAddr;

	}	

CMDnsAddrParamSet::~CMDnsAddrParamSet()

	{

	iDomainName.Close();

	}	

//-----------------------------------------------------------------------------------

CMDnsTxtParamSet* CMDnsTxtParamSet::NewL(RParameterFamily& aFamily)	

	{

	return static_cast < CMDnsTxtParamSet* > ( CMDnsParamSetBase::NewL( aFamily, EMdnsTxtParamset ) );	

	}

void CMDnsTxtParamSet::SetDomainNameL(const TDesC8& aDomainName)

	{

	iDomainName.Close ();

	iDomainName.CreateL(aDomainName);	

	}

const TDesC8& CMDnsTxtParamSet::DomainName() const

	{

	return iDomainName;	

	}

void CMDnsTxtParamSet::AppendTxtData(TDesC8& aData)

	{

	_LIT8(KNewLine,"\n");

	RBuf8 temp;

	temp.Create(iTxtData.Length() + aData.Length() + KNewLine().Length());

	temp.Append(iTxtData);

	temp.Append(aData);

	temp.Append(KNewLine);

	iTxtData.Close();

	iTxtData.Create(temp);

	temp.Close();

	}

void CMDnsTxtParamSet::TxtDataL(RArray<RBuf8>& aTxtArray)

	{

	TokenizeStringL(iTxtData,aTxtArray,'\n');

	}

void CMDnsTxtParamSet::TokenizeStringL(RBuf8& aString, RArray<RBuf8>& aList, TChar aSeparator)

	{

	TLex8 lexer(aString);

	while(!lexer.Eos())

		{

		lexer.SkipSpaceAndMark();

		while(!lexer.Eos() && lexer.Get() != aSeparator)

			{

			}

		if(!lexer.Eos())

			{

			lexer.UnGet(); // Do not include trailing ','

			}

		RBuf8 temp;

		temp.Create(lexer.MarkedToken());

		aList.Append(temp);

		lexer.Inc();

		}

	}

CMDnsTxtParamSet::~CMDnsTxtParamSet()

	{

	iDomainName.Close();

	iTxtData.Close();

	}		

//-----------------------------------------------------------------------------------

CMDnsPublishResponseParamSet* CMDnsPublishResponseParamSet::NewL(RParameterFamily& aFamily)	

	{

	return static_cast < CMDnsPublishResponseParamSet* > ( CMDnsParamSetBase::NewL( aFamily, EMdnsSrvParamset ) );	

	}

void CMDnsPublishResponseParamSet::SetDomainNameL(const TDesC8& aDomainName)

	{

	iDomainName.Close ();

	iDomainName.CreateL(aDomainName);	

	}

const TDesC8& CMDnsPublishResponseParamSet::DomainName() const

	{

	return iDomainName;	

	}

void CMDnsPublishResponseParamSet::SetError(TInt aError)

	{

	iError = aError;

	}

TInt CMDnsPublishResponseParamSet::Error()const

	{

	return iError;

	}

CMDnsPublishResponseParamSet::~CMDnsPublishResponseParamSet()

	{

	iDomainName.Close();

	}		

//----------------------------------------------------------------------------------------------------------------------------

CMDnsRegisterNotifyParamSet* CMDnsRegisterNotifyParamSet::NewL(RParameterFamily& aFamily)

	{

	return static_cast < CMDnsRegisterNotifyParamSet* > ( CMDnsParamSetBase::NewL( aFamily, EMdnsRegisterNotifyParamset ) );	

	}

void CMDnsRegisterNotifyParamSet::SetInstanceNameL(const TDesC8& aDomainName)

	{

	iInstanceName.Close ();

	iInstanceName.CreateL(aDomainName);	

	}

const TDesC8& CMDnsRegisterNotifyParamSet::InstanceName() const

	{

	return iInstanceName;	

	}

CMDnsRegisterNotifyParamSet::~CMDnsRegisterNotifyParamSet()

	{

	iInstanceName.Close();

	}	

//-----------------------------------------------------------------------------------

CMDnsPublishParamSet* CMDnsPublishParamSet::NewL(RParameterFamily& aFamily)	

	{

	return static_cast < CMDnsPublishParamSet* > ( CMDnsParamSetBase::NewL( aFamily, EMdnsPublishParamset ) );	

	}

void CMDnsPublishParamSet::SetPublishUpdate(TBool aFlag)

	{

	isPublish = aFlag;

	}

TBool CMDnsPublishParamSet::PublishUpdate()const

	{

	return isPublish;	

	}

CMDnsPublishParamSet::~CMDnsPublishParamSet()

	{

	}		

//----------------------------------------------------------------------------------------------------------------------------