/*

* Copyright (c) 2006-2007 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 <es_sock.h>

#include "natfwunsafunknownattributesattribute.h"

#include "natfwunsafutils.h"

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

// CNATFWUNSAFUnknownAttributesAttribute::NewL

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

//

EXPORT_C CNATFWUNSAFUnknownAttributesAttribute*

CNATFWUNSAFUnknownAttributesAttribute::NewL()

    {

    CNATFWUNSAFUnknownAttributesAttribute* self =

        CNATFWUNSAFUnknownAttributesAttribute::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

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

// CNATFWUNSAFUnknownAttributesAttribute::NewLC

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

//

EXPORT_C CNATFWUNSAFUnknownAttributesAttribute*

CNATFWUNSAFUnknownAttributesAttribute::NewLC()

    {

    CNATFWUNSAFUnknownAttributesAttribute* self =

        new (ELeave) CNATFWUNSAFUnknownAttributesAttribute();

    CleanupStack::PushL(self);

    return self;

    }

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

// CNATFWUNSAFUnknownAttributesAttribute::DecodeAttributeL

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

//

CNATFWUNSAFAttribute*

CNATFWUNSAFUnknownAttributesAttribute::DecodeAttributeL(

    const TDesC8& aByteStream)

    {

    TUint16 valueLength = ParseLengthL(aByteStream);

    //Stream has to have enough data for the whole value element

    __ASSERT_ALWAYS(aByteStream.Length() >= EValueOffset + valueLength,

                    User::Leave(KErrArgument));

    //Check the value length is valid for this attribute

    CheckLengthL(valueLength);

    CNATFWUNSAFUnknownAttributesAttribute* self =

        new (ELeave) CNATFWUNSAFUnknownAttributesAttribute();

    CleanupStack::PushL(self);

    self->DecodeValueL(aByteStream.Mid(EValueOffset, valueLength));

    CleanupStack::Pop(self);

    return self;

    }

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

// CNATFWUNSAFUnknownAttributesAttribute::CNATFWUNSAFUnknownAttributesAttribute

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

//

CNATFWUNSAFUnknownAttributesAttribute::CNATFWUNSAFUnknownAttributesAttribute() :

    CNATFWUNSAFAttribute()

#ifdef TEST_EUNIT

    , iContainedAttributes(1)

#endif

    {

    }

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

// CNATFWUNSAFUnknownAttributesAttribute::~CNATFWUNSAFUnknownAttributesAttribute

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

//

EXPORT_C CNATFWUNSAFUnknownAttributesAttribute::

~CNATFWUNSAFUnknownAttributesAttribute()

    {

    iContainedAttributes.Close();

    }

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

// CNATFWUNSAFUnknownAttributesAttribute::Type

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

//

CNATFWUNSAFAttribute::TType CNATFWUNSAFUnknownAttributesAttribute::Type() const

    {

    __TEST_INVARIANT;

    return EUnknownAttributes;

    }

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

// CNATFWUNSAFUnknownAttributesAttribute::EncodeValueL

// If the number of attributes is an odd number, one attribute is repeated.

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

//

HBufC8* CNATFWUNSAFUnknownAttributesAttribute::EncodeValueL() const

    {

    __TEST_INVARIANT;

    TInt count = iContainedAttributes.Count();

    if (count & 0x1)

        {

        count++;

        }

    HBufC8* encodedValue = HBufC8::NewLC(count * EElementSize);

    TPtr8 ptr = encodedValue->Des();

    ptr.FillZ(count * EElementSize);

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

        {

        TUint16 value = static_cast<TUint16>(iContainedAttributes[i]);

        NATFWUNSAFUtils::WriteNetworkOrder16L(ptr,

                                         i * EElementSize,

                                         value);

        }

    if (count > iContainedAttributes.Count())

        {

        TUint16 value = static_cast<TUint16>(iContainedAttributes[0]);

        NATFWUNSAFUtils::WriteNetworkOrder16L(ptr,

                                 iContainedAttributes.Count() * EElementSize,

                                 value);

        }

    CleanupStack::Pop(encodedValue);

    return encodedValue;

    }

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

// CNATFWUNSAFUnknownAttributesAttribute::AddContainedAttributeL

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

//

void CNATFWUNSAFUnknownAttributesAttribute::AddContainedAttributeL(

    TUint16 aAttributeType)

    {

    __ASSERT_ALWAYS(iContainedAttributes.Find(aAttributeType) == KErrNotFound,

                    User::Leave(KErrAlreadyExists));

    iContainedAttributes.AppendL(aAttributeType);

    }

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

// CNATFWUNSAFUnknownAttributesAttribute::RemoveContainedAttribute

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

//

TInt CNATFWUNSAFUnknownAttributesAttribute::RemoveContainedAttribute(

    TUint16 aAttributeType)

    {

    TInt index = iContainedAttributes.Find(aAttributeType);

    if (index == KErrNotFound)

        {

        return KErrNotFound;

        }

    iContainedAttributes.Remove(index);

    return KErrNone;

    }

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

// CNATFWUNSAFUnknownAttributesAttribute::ContainedAttributes

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

//

EXPORT_C const RArray<TUint32>& CNATFWUNSAFUnknownAttributesAttribute::

ContainedAttributes() const

    {

    __TEST_INVARIANT;

    return iContainedAttributes;

    }

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

// CNATFWUNSAFUnknownAttributesAttribute::CheckLengthL

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

//

void CNATFWUNSAFUnknownAttributesAttribute::CheckLengthL(TInt aLength)

    {

    __ASSERT_ALWAYS((aLength % EGranularity) == 0, User::Leave(KErrCorrupt));

    }

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

// CNATFWUNSAFUnknownAttributesAttribute::DecodeValueL

// If the number of attributes would be an odd number, one attribute is

// repeated. The repeated attribute is not placed into iContainedAttributes

// array.

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

//

void CNATFWUNSAFUnknownAttributesAttribute::DecodeValueL(const TDesC8& aValue)

    {

    for (TInt pos = 0; pos < aValue.Length(); pos = pos + EElementSize)

        {

        TUint attrType = BigEndian::Get16(aValue.Mid(pos).Ptr());

        if (iContainedAttributes.Find(attrType) == KErrNotFound)

            {

            iContainedAttributes.AppendL(attrType);

            }

        }

    }

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

// CNATFWUNSAFUnknownAttributesAttribute::__DbgTestInvariant

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

//

void CNATFWUNSAFUnknownAttributesAttribute::__DbgTestInvariant() const

    {

#if defined(_DEBUG)

/*    if ( error )

        {

        User::Invariant();

        } */

#endif

    }