// Copyright (c) 2003-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          : SdpRepeatField.h

// Part of       : SDP Codec

// Version       : 1.0

//

#include <s32strm.h>

#include "SdpRepeatField.h"

#include "SdpUtil.h"

#include "SDPCodec.pan"

#include "_sdpdefs.h"

#include "sdpcodecstringconstants.h"

#include "SdpDocument.h"

#include "SdpCodecConstants.h"

#include "SdpCodecErr.h"

#include "SdpCodecStringPool.h"

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

// CSdpRepeatField::DecodeL

// Decodes bandwidth field from TDesC

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

//

EXPORT_C CSdpRepeatField* CSdpRepeatField::DecodeL(const TDesC8& aText)

	{

	CSdpRepeatField* obj = DecodeLC(aText);

	CleanupStack::Pop();

	return obj;

	}

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

// CSdpRepeatField::DecodeLC

// Decodes bandwidth field from TDesC

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

//

EXPORT_C CSdpRepeatField* CSdpRepeatField::DecodeLC(const TDesC8& aText)

	{

    CSdpRepeatField* obj = new (ELeave) CSdpRepeatField();

	CleanupStack::PushL(obj);

	obj->ConstructL(aText);

	return obj;

	}

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

// CSdpRepeatField::NewL

// Two-phased constructor

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

//

EXPORT_C CSdpRepeatField* CSdpRepeatField::NewL(

                                        const TSdpTypedTime aRepeatInterval,

										const TSdpTypedTime  aActiveDuration,

										const RArray<TSdpTypedTime>& aOffsets)

	{

	CSdpRepeatField* obj = NewLC(aRepeatInterval, aActiveDuration, aOffsets);

	CleanupStack::Pop();

	return obj;

	}

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

// CSdpRepeatField::NewLC

// Two-phased constructor

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

//

EXPORT_C CSdpRepeatField* CSdpRepeatField::NewLC(

                                        const TSdpTypedTime aRepeatInterval,

										const TSdpTypedTime aActiveDuration,

										const RArray<TSdpTypedTime>& aOffsets)

	{

	CSdpRepeatField* obj = new (ELeave) CSdpRepeatField(aRepeatInterval,

                                                    aActiveDuration);

	CleanupStack::PushL(obj);

	obj->ConstructL(aOffsets);

	return obj;

	}

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

// CSdpRepeatField::~CSdpRepeatField

// Destructor

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

//

EXPORT_C CSdpRepeatField::~CSdpRepeatField()

	{

    iTimeOffsets.Close();

	}

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

// CSdpRepeatField::EncodeL

// Writes attributes in proper format to the stream

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

//

EXPORT_C void CSdpRepeatField::EncodeL(RWriteStream& aStream) const

    {

    const TDesC8& repeatName = iPool.StringF(SdpCodecStringConstants::ERepeat, 

                                        SdpCodecStringConstants::Table).DesC();

    aStream.WriteL(repeatName);

    iRepeatInterval.EncodeL(aStream);

    aStream.WriteL(KSPStr);

    iActiveDuration.EncodeL(aStream);

    for (TInt i = 0; i < iTimeOffsets.Count(); i++)

        {

        aStream.WriteL(KSPStr);

        (iTimeOffsets)[i].EncodeL(aStream);

        }

    aStream.WriteL(KCRLFStr);

    }

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

// CSdpRepeatField::CloneL

// Creates an exact copy of the repeat field

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

//

EXPORT_C CSdpRepeatField* CSdpRepeatField::CloneL() const

	{

	__TEST_INVARIANT;

	CSdpRepeatField* obj = NewL(iRepeatInterval, iActiveDuration, 

                                iTimeOffsets);

	__ASSERT_DEBUG(*this == *obj, User::Panic(KSdpCodecPanicCat, 

                                            KSdpCodecPanicInternal));

	return obj;

	}

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

// CSdpRepeatField::operator ==

// Checks if two repeat fields are equal

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

//

EXPORT_C TBool CSdpRepeatField::operator == (const CSdpRepeatField & aObj) 

        const

	{

	__TEST_INVARIANT;

	TBool result = iRepeatInterval == aObj.iRepeatInterval

		&& iActiveDuration == aObj.iActiveDuration

		&& iTimeOffsets.Count() == (aObj.iTimeOffsets).Count();

	if (result)

		{

		int i = 0;

		while (result && i < iTimeOffsets.Count())

			{

			result = (iTimeOffsets)[i] == (aObj.iTimeOffsets)[i];

			i++;

			}

		}

	return result;

	}

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

// CSdpRepeatField::RepeatInterval

// Return repeat interval value

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

//

EXPORT_C const TSdpTypedTime CSdpRepeatField::RepeatInterval() const

	{

	__TEST_INVARIANT;

	return iRepeatInterval;

	}

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

// CSdpRepeatField::SetRepeatIntervalL

// Sets repeat interval to one of predefined values

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

//

EXPORT_C void CSdpRepeatField::SetRepeatIntervalL(const TSdpTypedTime aValue)

	{

	__TEST_INVARIANT;

    __ASSERT_ALWAYS(aValue.iValue > 0, User::Leave(KErrSdpCodecRepeatField));

    iRepeatInterval = aValue;

	__TEST_INVARIANT;

	}

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

// CSdpRepeatField::ActiveDuration

// Returns active duration value

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

//

EXPORT_C const TSdpTypedTime CSdpRepeatField::ActiveDuration() const

	{

	__TEST_INVARIANT;

	return iActiveDuration;

	}

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

// CSdpRepeatField::SetActiveDuration

// Sets new active duration value

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

//

EXPORT_C void CSdpRepeatField::SetActiveDuration(const TSdpTypedTime aValue)

	{

	__TEST_INVARIANT;

	iActiveDuration = aValue;

	__TEST_INVARIANT;

	}

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

// CSdpRepeatField::TimeOffsets

// CReturns timeoffsets

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

//

EXPORT_C const RArray<TSdpTypedTime>& CSdpRepeatField::TimeOffsets() const

	{

	__TEST_INVARIANT;

	return iTimeOffsets;

	}

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

// CSdpRepeatField::SetTimeOffsetsL

// Sets timeoffsets

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

//

EXPORT_C void CSdpRepeatField::SetTimeOffsetsL(

                                        const RArray<TSdpTypedTime>& aValue)

    {

    RArray<TSdpTypedTime> tempOffsets;                 

    if (aValue.Count() > 0)

	    {

        CleanupClosePushL( tempOffsets );         

		for (TInt i = 0; i < aValue.Count(); i++)

		    {

            User::LeaveIfError(tempOffsets.Append(aValue[i]));

			}

        CleanupStack::Pop();    // tempOffsets

        iTimeOffsets.Close();

        iTimeOffsets = tempOffsets;

        }

    else

        {

   	    // remove old timeoffsets

        iTimeOffsets.Reset();

        }

    }

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

// CSdpRepeatField::ExternalizeL

// Externalizes the object to stream

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

//

void CSdpRepeatField::ExternalizeL(RWriteStream& aStream) const

    {

    iRepeatInterval.ExternalizeL(aStream);

    iActiveDuration.ExternalizeL(aStream);

    aStream.WriteUint32L(iTimeOffsets.Count());

    for (TInt i = 0; i < iTimeOffsets.Count(); i++)

        {

        (iTimeOffsets)[i].ExternalizeL(aStream);

        }

    }

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

// CSdpRepeatField::InternalizeL

// Internalizes the object from stream

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

//

CSdpRepeatField* CSdpRepeatField::InternalizeL(RReadStream& aStream)

    {

    const TSdpTypedTime repeatInterval = TSdpTypedTime::InternalizeL(aStream);

    TSdpTypedTime activeDuration = TSdpTypedTime::InternalizeL(aStream);

    TUint32 offsetsCount = aStream.ReadUint32L();

    RArray<TSdpTypedTime> offsets;

    CleanupClosePushL(offsets);

    if (offsetsCount > 0)

        {

		for (TUint i = 0; i < offsetsCount; i++)

			{

            User::LeaveIfError(offsets.Append(

                TSdpTypedTime::InternalizeL(aStream)));

			}

        }

    CSdpRepeatField* obj = CSdpRepeatField::NewL(repeatInterval,

                                                activeDuration, offsets);

    CleanupStack::PopAndDestroy(); // offsets

    return obj;

    }

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

// CSdpRepeatField::CSdpRepeatField

// Constructor

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

//

CSdpRepeatField::CSdpRepeatField(const TSdpTypedTime aRepeatInterval,

								const TSdpTypedTime aActiveDuration)

:	iRepeatInterval(aRepeatInterval), iActiveDuration(aActiveDuration)

	{

	}

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

// CSdpRepeatField::CSdpRepeatField

// Constructor

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

//

CSdpRepeatField::CSdpRepeatField()

	{

	}

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

// CSdpRepeatField::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSdpRepeatField::ConstructL(const TDesC8& aText)

	{

    iPool = SdpCodecStringPool::StringPoolL();

    RArray <TPtrC8> lines;

    lines = SdpUtil::DivideToLinesL(aText, KErrSdpCodecRepeatField);

    CleanupClosePushL(lines);

    RArray<TPtrC8> repeatArray;

    repeatArray = SdpUtil::GetElementsFromLineL(lines[0], 

                                                KErrSdpCodecRepeatField);

    CleanupClosePushL(repeatArray);

    const TDesC8& repeatName = iPool.StringF(SdpCodecStringConstants::ERepeat,

                                        SdpCodecStringConstants::Table).DesC();    

    __ASSERT_ALWAYS(lines.Count() == 1

        && repeatArray.Count() >= 3

        && repeatName.CompareF(repeatArray[0]) == 0,

        User::Leave(KErrSdpCodecRepeatField));

    // repeat interval

    __ASSERT_ALWAYS(TLex8(repeatArray[1]).Peek() != '0', 

        User::Leave(KErrSdpCodecRepeatField));

    iRepeatInterval = TSdpTypedTime::DecodeL(repeatArray[1]);

    // active duration

    iActiveDuration = TSdpTypedTime::DecodeL(repeatArray[2]);

	if (repeatArray.Count() > 3)

		{

		for (TInt i = 3; i < repeatArray.Count(); i++)

			{

            User::LeaveIfError(iTimeOffsets.Append(

                TSdpTypedTime::DecodeL(repeatArray[i])));

			}

		}

    CleanupStack::PopAndDestroy(2); // lines, repeatArray

	__TEST_INVARIANT;

	}

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

// CSdpRepeatField::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CSdpRepeatField::ConstructL(const RArray<TSdpTypedTime>& aOffsets)

	{

    __ASSERT_ALWAYS(iRepeatInterval.iValue > 0, 

                    User::Leave(KErrSdpCodecRepeatField));

    iPool = SdpCodecStringPool::StringPoolL();

    if (aOffsets.Count() > 0)

		{

        for (TInt i = 0; i < aOffsets.Count(); i++)

			{

            User::LeaveIfError(iTimeOffsets.Append(aOffsets[i]));

			}

		}

	__TEST_INVARIANT;

	}

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

// CSdpRepeatField::__DbgTestInvariant

// Test invariant

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

//

void CSdpRepeatField::__DbgTestInvariant() const

	{

	TBool invariant = iRepeatInterval.iValue > 0;

	if (!invariant)

		User::Invariant();

	}