/*
* Copyright (c) 2006 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:  CJavaAttribute implementation
*
*/


#include <s32mem.h>
#include "javaattributes.h"

using namespace Java::Manager::Registry;

// ============================ MEMBER FUNCTIONS ==============================

// ---------------------------------------------------------------------------
// CJavaAttribute::NewL
// Constructs a CJavaAttributes object.
// ---------------------------------------------------------------------------
EXPORT_C CJavaAttributes* CJavaAttributes::NewL()
{
    CJavaAttributes* self = CJavaAttributes::NewLC();
    CleanupStack::Pop(self);
    return self;
}

// ---------------------------------------------------------------------------
// CJavaAttributes::NewLC
// Constructs a CJavaAttributes object.
// ---------------------------------------------------------------------------
EXPORT_C CJavaAttributes* CJavaAttributes::NewLC()
{
    CJavaAttributes* self = new(ELeave) CJavaAttributes();
    CleanupStack::PushL(self);
    self->ConstructL(NULL);
    return self;
}

// ---------------------------------------------------------------------------
// CJavaAttribute::NewL
// Constructs a CJavaAttributes object.
// ---------------------------------------------------------------------------
EXPORT_C CJavaAttributes* CJavaAttributes::NewL(TDesC8* aBuffer)
{
    CJavaAttributes* self = CJavaAttributes::NewLC(aBuffer);
    CleanupStack::Pop(self);
    return self;
}

// ---------------------------------------------------------------------------
// CJavaAttribute::NewLC
// Constructs a CJavaAttribute object.
// ---------------------------------------------------------------------------
EXPORT_C CJavaAttributes* CJavaAttributes::NewLC(TDesC8* aBuffer)
{
    CJavaAttributes* self = new(ELeave) CJavaAttributes();
    CleanupStack::PushL(self);
    self->ConstructL(aBuffer);
    return self;
}

// ---------------------------------------------------------------------------
// CJavaAttribute::ConstructL
// ---------------------------------------------------------------------------
void CJavaAttributes::ConstructL(TDesC8* aBuffer)
{
    if (aBuffer)
    {
        RDesReadStream stream(*aBuffer);
        CleanupClosePushL(stream);
        stream >> *this;
        CleanupStack::PopAndDestroy(&stream);
    }
    else
    {
        iAttributes.Reset();
    }
}

// ---------------------------------------------------------------------------
// CJavaAttribute::ConstructL
// ---------------------------------------------------------------------------
EXPORT_C CJavaAttributes::~CJavaAttributes()
{
    DeleteAttributes();
}

// ---------------------------------------------------------------------------
// CJavaAttributes::Count
// Returns TInt
// ---------------------------------------------------------------------------
EXPORT_C TInt CJavaAttributes::Count() const
{
    return iAttributes.Count();
}

// ---------------------------------------------------------------------------
// CJavaAttributes::GetAttribute
// Returns MJavaAttribute&
// ---------------------------------------------------------------------------
EXPORT_C const MJavaAttribute* CJavaAttributes::
Attribute(const TDesC& aName) const
{
    TInt i = 0;
    while (i < iAttributes.Count())
    {
        if (iAttributes[i]->Name() == aName)
        {
            return iAttributes[i];
        }
        else
        {
            i = i + 1;
        }
    }
    return NULL;
}

// ---------------------------------------------------------------------------
// CJavaAttributes::GetAttributes
// Returns RPointerArray&
// ---------------------------------------------------------------------------
EXPORT_C const RPointerArray< MJavaAttribute >&
CJavaAttributes::Attributes() const
{
    return iAttributes;
}

// ---------------------------------------------------------------------------
// CJavaAttributes::AddAttributeL
// Returns TInt
// ---------------------------------------------------------------------------
EXPORT_C void CJavaAttributes::AddAttributeL(MJavaAttribute* aAttribute)
{
    TInt i = 0;
    MJavaAttribute* attr = NULL;
    // Check if attribute with the same name exist, if yes delete it.
    while (i < iAttributes.Count())
    {
        if (iAttributes[i]->Name() == aAttribute->Name())
        {
            attr = iAttributes[i];
            break;
        }
        i = i + 1;
    }
    if (attr)
    {
        delete attr;
        iAttributes.Remove(i);
    }
    TInt err = iAttributes.Append(aAttribute);
    if (err)
    {
        delete aAttribute;     //delete not added attribute
        User::Leave(err);
    }
}

// ---------------------------------------------------------------------------
// CJavaAttributes::AddAttributeL
// Returns TInt
// ---------------------------------------------------------------------------
EXPORT_C void CJavaAttributes::
AddAttributeL(const TDesC& aName, const TDesC& aValue, TBool aTrusted)
{
    CJavaAttribute* attribute = CJavaAttribute::NewL(aName, aValue, aTrusted);
    AddAttributeL(attribute);
}

// ---------------------------------------------------------------------------
// CJavaAttributes::DeleteAttributes
// ---------------------------------------------------------------------------
EXPORT_C void CJavaAttributes::DeleteAttributes()
{
    TInt count = iAttributes.Count();
    for (TInt i = 0; i < count; i++)
    {
        delete iAttributes[i];
        iAttributes[i] = NULL;
    }
    iAttributes.ResetAndDestroy();
}

// ---------------------------------------------------------------------------
// CJavaAttributes::ExternalizeL
// ---------------------------------------------------------------------------
void CJavaAttributes::ExternalizeL(RWriteStream& aStream) const
{
    TInt32 attr_count = iAttributes.Count();
    aStream << attr_count;
    for (TInt i = 0; i < attr_count; i++)
    {
        MJavaAttribute* attr = iAttributes[i];
        TInt32 val = attr->Name().Length();
        aStream << val << attr->Name();
        val = attr->Value().Length();
        aStream << val << attr->Value();
        val = attr->Trusted();
        aStream << val;
    }
}

// ---------------------------------------------------------------------------
// CJavaAttributes::InternalizeL
// ---------------------------------------------------------------------------
void CJavaAttributes::InternalizeL(RReadStream& aStream)
{
    if (iAttributes.Count())    // if exist some attributes delete it
    {
        DeleteAttributes();
    }
    TInt32 count;
    aStream >> count;      // read number of attributes
    for (TInt i = 0; i < count; i++)
    {
        HBufC* name;
        HBufC* value;
        TInt32 trusted;
        TInt32 len;
        aStream >> len;
        name = HBufC::NewLC(aStream, len);
        aStream >> len;
        value = HBufC::NewLC(aStream, len);
        aStream >> trusted;
        MJavaAttribute* attr = CJavaAttribute::
                               NewL(*name, *value, STATIC_CAST(TBool, trusted));
        CleanupStack::PopAndDestroy(value);          //value
        CleanupStack::PopAndDestroy(name);       // name
        TInt err = iAttributes.Append(attr);
        if (err)
        {
            DeleteAttributes();    // delete appended properities
            delete attr;           // delete not appended property
            User::Leave(err);
        }
    }

}

// ---------------------------------------------------------------------------
// CJavaAttributes::Size
// Returns TInt;
// ---------------------------------------------------------------------------
EXPORT_C TInt CJavaAttributes::Size() const
{

    TInt size = sizeof(TInt32);                          // size of count
    TInt count = iAttributes.Count();
    TInt boolsize = sizeof(TBool);
    TInt int32size =  sizeof(TInt32);
    // size of all value "IsTrusted" and size of stored size
    size += count * (boolsize + (int32size * 2));
    // add sizes of name and value of all attributes
    for (TInt i = 0; i < count; i++)
    {
        MJavaAttribute* attr = iAttributes[i];
        size += attr->Name().Size();
        size += attr->Value().Size();
    }
    return size;
}


// ---------------------------------------------------------------------------
// CJavaAttributes::SerializedAttributesL
// Returns HBufC8* serialized CJavaAttributes object;
// ---------------------------------------------------------------------------
EXPORT_C HBufC8* CJavaAttributes::SerializedAttributesL() const
{
    TInt32 size = Size();
    HBufC8* buffer = HBufC8::NewLC(size);
    TPtr8 des8 = buffer->Des();
    RDesWriteStream stream(des8);
    CleanupClosePushL(stream);
    stream << *this;
    stream.CommitL();
    CleanupStack::PopAndDestroy(&stream);        // stream
    CleanupStack::Pop(buffer);                  // buffer
    return buffer;
}

// End of File