// Copyright (c) 2004-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:
// Name        : CSIPPAccessNetworkInfoHeader.cpp
// Part of     : SIP Codec
// Interface   : SDK API, SIP Codec API
// Version     : SIP/4.0 
//



#include "sippaccessnetworkinfoheader.h"
#include "CSIPPAccessNetworkInfoHeaderParams.h"
#include "SIPSyntaxCheck.h"
#include "sipcodecerr.h"
#include "sipstrings.h"
#include "sipcodecutils.h"
#include "sipstrconsts.h"
#include "_sipcodecdefs.h"


// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::DecodeL
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPPAccessNetworkInfoHeader* 
	CSIPPAccessNetworkInfoHeader::DecodeL(const TDesC8& aValue)
    {
    __ASSERT_ALWAYS(aValue.Length() > 0,
		User::Leave (KErrSipCodecPAccessNetworkInfoHeader));

    CSIPPAccessNetworkInfoHeader* header = 
        new(ELeave) CSIPPAccessNetworkInfoHeader;
    CleanupStack::PushL(header);
    header->ConstructL();
    header->ParseL(aValue);
    CleanupStack::Pop(header);
    return header;
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::NewL
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPPAccessNetworkInfoHeader* 
    CSIPPAccessNetworkInfoHeader::NewL(RStringF aAccessType)
    {
    CSIPPAccessNetworkInfoHeader* self = 
        CSIPPAccessNetworkInfoHeader::NewLC(aAccessType);
    CleanupStack::Pop(self);
    return self;
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::NewLC
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPPAccessNetworkInfoHeader* 
    CSIPPAccessNetworkInfoHeader::NewLC(RStringF aAccessType)
    {
    CSIPPAccessNetworkInfoHeader* self = 
        new (ELeave)CSIPPAccessNetworkInfoHeader;
    CleanupStack::PushL(self);
    self->ConstructL(aAccessType);
    return self;
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::~CSIPPAccessNetworkInfoHeader
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPPAccessNetworkInfoHeader::~CSIPPAccessNetworkInfoHeader()
    {
    iAccessType.Close();
    delete iParams;
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::CSIPPAccessNetworkInfoHeader
// ----------------------------------------------------------------------------
//
CSIPPAccessNetworkInfoHeader::CSIPPAccessNetworkInfoHeader()
: CSIPParameterHeaderBase(';')
    {
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPPAccessNetworkInfoHeader::ConstructL()		
    {
    iParams = new (ELeave) CSIPPAccessNetworkInfoHeaderParams;
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPPAccessNetworkInfoHeader::ConstructL(RStringF aAccessType)
    {
    ConstructL();
    SetAccessTypeL(aAccessType);
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPPAccessNetworkInfoHeader::ConstructL(
                                const CSIPPAccessNetworkInfoHeader& aHeader)
    {
    SetAccessTypeL(aHeader.AccessType());
    iParams = CSIPPAccessNetworkInfoHeaderParams::NewL(*(aHeader.iParams));
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::SetAccessTypeL
// ----------------------------------------------------------------------------
//
EXPORT_C void CSIPPAccessNetworkInfoHeader::SetAccessTypeL(RStringF 
                                                           aAccessType)
    {
    RStringF tmp = 
        SIPCodecUtils::CheckAndCreateTokenL(
            aAccessType.DesC(), KErrSipCodecPAccessNetworkInfoHeader);
	iAccessType.Close();
    iAccessType = tmp;    
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::AccessType
// ----------------------------------------------------------------------------
//
EXPORT_C RStringF CSIPPAccessNetworkInfoHeader::AccessType() const
    {
    return iAccessType;
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::CloneL
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPHeaderBase* CSIPPAccessNetworkInfoHeader::CloneL() const
    {
    CSIPPAccessNetworkInfoHeader* header = 
        new(ELeave) CSIPPAccessNetworkInfoHeader;
    CleanupStack::PushL(header);
    header->ConstructL(*this);
    CleanupStack::Pop(header);
    return header;
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::Name
// ----------------------------------------------------------------------------
//
EXPORT_C RStringF CSIPPAccessNetworkInfoHeader::Name() const
    {
    return SIPStrings::StringF(SipStrConsts::EPAccessNetworkInfoHeader);
    }
    
// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::ExternalizeSupported
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
EXPORT_C TBool CSIPPAccessNetworkInfoHeader::ExternalizeSupported () const
	{
	return EFalse;
	}    

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::PreferredPlaceInMessage
// ----------------------------------------------------------------------------
//
CSIPHeaderBase::TPreferredPlace 
CSIPPAccessNetworkInfoHeader::PreferredPlaceInMessage() const
    {
    return CSIPHeaderBase::EMiddleBottom;
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::BaseDecodeL
// ----------------------------------------------------------------------------
//
RPointerArray<CSIPHeaderBase> 
CSIPPAccessNetworkInfoHeader::BaseDecodeL(const TDesC8& aValue)
    {
	CSIPPAccessNetworkInfoHeader* header = DecodeL(aValue);
	CleanupStack::PushL(header);
	RPointerArray<CSIPHeaderBase> headers;
	User::LeaveIfError (headers.Append(header));
	CleanupStack::Pop(header);
	return headers;	
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::ToTextMandatoryPartLC
// ----------------------------------------------------------------------------
//
HBufC8* CSIPPAccessNetworkInfoHeader::ToTextMandatoryPartLC() const
    {
    return iAccessType.DesC().AllocLC();
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::ParseMandatoryPartL
// ----------------------------------------------------------------------------
//
void CSIPPAccessNetworkInfoHeader::ParseMandatoryPartL(
                                                  const TDesC8& aMandatoryPart)
    {
    __ASSERT_ALWAYS(aMandatoryPart.Length() > 0,
		User::Leave (KErrSipCodecPAccessNetworkInfoHeader));

	TLex8 lex(aMandatoryPart);
	lex.SkipSpace();
    RStringF accessType = SIPStrings::Pool().OpenFStringL(lex.Remainder());
    CleanupClosePushL(accessType);
	SetAccessTypeL(accessType);
    CleanupStack::PopAndDestroy(&accessType);
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::Params
// ----------------------------------------------------------------------------
//
const CSIPParamContainerBase& CSIPPAccessNetworkInfoHeader::Params() const
    {
    return *iParams;
    }

// ----------------------------------------------------------------------------
// CSIPPAccessNetworkInfoHeader::Params
// ----------------------------------------------------------------------------
//
CSIPParamContainerBase& CSIPPAccessNetworkInfoHeader::Params()
    {
    return *iParams;
    }