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





#include "SipRequestElements.h"
#include "SipMessageElements.h"
#include "SipFromHeader.h"
#include "SipToHeader.h"
#include "uricontainer.h"
#include "sipstrings.h"
#include "sipstrconsts.h"
#include "_sipcodecdefs.h"


// -----------------------------------------------------------------------------
// CSIPRequestElements::NewL
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPRequestElements* CSIPRequestElements::NewL(CUri8* aRemoteUri)
	{
    CSIPRequestElements* self = CSIPRequestElements::NewLC(aRemoteUri);
    CleanupStack::Pop (self);
    return self;
	}	

// -----------------------------------------------------------------------------
// CSIPRequestElements::NewLC
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPRequestElements* CSIPRequestElements::NewLC(CUri8* aRemoteUri)
	{
	CSIPRequestElements* self = new(ELeave)CSIPRequestElements;
    CleanupStack::PushL (self);
    self->ConstructL (aRemoteUri);
    return self;
	}

// -----------------------------------------------------------------------------
// CSIPRequestElements::CSIPRequestElements
// -----------------------------------------------------------------------------
//
CSIPRequestElements::CSIPRequestElements() 
	{
	}

// -----------------------------------------------------------------------------
// CSIPRequestElements::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPRequestElements::ConstructL(CUri8* aRemoteUri)
	{
	__ASSERT_ALWAYS (aRemoteUri != 0, User::Leave(KErrArgument));

	iMessageElements = CSIPMessageElements::NewL();
    SetRemoteUriL(aRemoteUri);
	}

// -----------------------------------------------------------------------------
// CSIPRequestElements::~CSIPRequestElements
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPRequestElements::~CSIPRequestElements() 
	{
    delete iRemoteURI;
    iMethod.Close();
	delete iMessageElements;
	}

// -----------------------------------------------------------------------------
// CSIPRequestElements::SetToHeaderL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPRequestElements::SetToHeaderL(CSIPToHeader* aTo)
    {
    iMessageElements->SetToL(aTo);
    }
			
// -----------------------------------------------------------------------------
// CSIPRequestElements::ToHeader
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPToHeader* CSIPRequestElements::ToHeader() const  
    {
    return iMessageElements->To();
    }

// -----------------------------------------------------------------------------
// CSIPRequestElements::SetFromHeaderL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPRequestElements::SetFromHeaderL(CSIPFromHeader* aFrom)
    {
    iMessageElements->SetFromL(aFrom);
    }
			
// -----------------------------------------------------------------------------
// CSIPRequestElements::FromHeader
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPFromHeader* CSIPRequestElements::FromHeader() const
    {
    return iMessageElements->From();
    }

// -----------------------------------------------------------------------------
// CSIPRequestElements::SetRemoteURIL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPRequestElements::SetRemoteUriL(CUri8* aRemoteUri)
    {
	__ASSERT_ALWAYS (aRemoteUri != 0, User::Leave(KErrArgument));
    CURIContainer* tmp = CURIContainer::NewL(aRemoteUri);
    delete iRemoteURI;
    iRemoteURI = tmp;
    }

// -----------------------------------------------------------------------------
// CSIPRequestElements::RemoteURI
// -----------------------------------------------------------------------------
//
EXPORT_C const CUri8& CSIPRequestElements::RemoteUri() const
    {
    return *(iRemoteURI->Uri8());
    }

// -----------------------------------------------------------------------------
// CSIPRequestElements::SetMethodL
// -----------------------------------------------------------------------------
//
EXPORT_C void CSIPRequestElements::SetMethodL(RStringF aMethod)
    {
	__ASSERT_ALWAYS (aMethod.DesC().Length() > 0, User::Leave(KErrArgument));

	iMethod.Close();
	iMethod = aMethod.Copy();
    }

// -----------------------------------------------------------------------------
// CSIPRequestElements::Method
// -----------------------------------------------------------------------------
//
EXPORT_C RStringF CSIPRequestElements::Method() const
    {
    return iMethod;
    }

// -----------------------------------------------------------------------------
// CSIPRequestElements::MessageElements
// -----------------------------------------------------------------------------
//
EXPORT_C const CSIPMessageElements& CSIPRequestElements::MessageElements() const
    {
    return *iMessageElements;
    }

// -----------------------------------------------------------------------------
// CSIPRequestElements::MessageElements
// -----------------------------------------------------------------------------
//
EXPORT_C CSIPMessageElements& CSIPRequestElements::MessageElements()
    {
    return *iMessageElements;
    }

// -----------------------------------------------------------------------------
// CSIPRequestElements::InternalizeL
// -----------------------------------------------------------------------------
//
CSIPRequestElements* CSIPRequestElements::InternalizeL(RReadStream& aReadStream)
	{
	CSIPRequestElements* self = new(ELeave)CSIPRequestElements;
    CleanupStack::PushL (self);
    self->DoInternalizeL(aReadStream);
	CleanupStack::Pop(); // self
    return self;
	}

// -----------------------------------------------------------------------------
// CSIPRequestElements::DoInternalizeL
// -----------------------------------------------------------------------------
//
void CSIPRequestElements::DoInternalizeL(RReadStream& aReadStream)
	{
    // For incoming requests the method is always present
	TUint32 methodLength = aReadStream.ReadUint32L();
    if (methodLength > 0)
        {
	    HBufC8* methodBuf = HBufC8::NewLC(methodLength);
	    TPtr8 methodPtr(methodBuf->Des());
	    aReadStream.ReadL(methodPtr,methodLength);
	    iMethod = SIPStrings::Pool().OpenFStringL(methodPtr);
	    CleanupStack::PopAndDestroy(methodBuf);
        }
    aReadStream.ReadUint8L(); // remote-URI always present
    //iRemoteURI = CURIContainer::InternalizeL(aReadStream);
    iMessageElements = CSIPMessageElements::InternalizeL(aReadStream);
	}

// -----------------------------------------------------------------------------
// CSIPRequestElements::ExternalizeL
// -----------------------------------------------------------------------------
//
void CSIPRequestElements::ExternalizeL(RWriteStream& aWriteStream) const
	{
	TPtrC8 method(iMethod.DesC());
    // For outgoing requests in some cases the method is filled in ServerCore
    if (method.Length() > 0)
        {
        aWriteStream.WriteUint32L(method.Length());
	    aWriteStream.WriteL(method);
        }
    aWriteStream.WriteUint8L(1); // remote-URI always present
    //iRemoteURI->ExternalizeL(aWriteStream);
    iMessageElements->ExternalizeL(aWriteStream);
	}
