/*

* Copyright (c) 2008-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:    Array of attribute retrieval errors

*

*/

#include "glxfetcherrorarray.h"

#include <glxtracer.h>                         // For Logs

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

// Constructor

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

//

CGlxFetchErrorArray::CGlxFetchErrorArray()

    {

    TRACER("CGlxFetchErrorArray::Default Constructor");

    }

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

// NewL

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

//

CGlxFetchErrorArray* CGlxFetchErrorArray::NewL(const CGlxFetchErrorArray* aErrorArray)

    {

    TRACER("CGlxFetchErrorArray::NewL");

    CGlxFetchErrorArray* self = CGlxFetchErrorArray::NewLC(aErrorArray);

    CleanupStack::Pop(self);

    return self;

    }

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

// NewLC

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

//

CGlxFetchErrorArray* CGlxFetchErrorArray::NewLC(const CGlxFetchErrorArray* aErrorArray)

    {

    TRACER("CGlxFetchErrorArray::NewLC");

    CGlxFetchErrorArray* self = new( ELeave ) CGlxFetchErrorArray();

    CleanupStack::PushL( self );

    self->CopyConstructL(aErrorArray);

    return self;

    }

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

// CopyConstructL

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

//

void CGlxFetchErrorArray::CopyConstructL(const CGlxFetchErrorArray* aErrorArray)

    {

    TRACER("CGlxFetchErrorArray::CopyConstructL");

    if ( aErrorArray )

        {

        TInt count = aErrorArray->iFetchErrors.Count();

        for ( TInt index = 0; index < count; index++ )

            {

            iFetchErrors.AppendL(aErrorArray->iFetchErrors[index]);

            }

        }

    }

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

// Destructor

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

//

CGlxFetchErrorArray::~CGlxFetchErrorArray()

    {

    TRACER("CGlxFetchErrorArray::Destructor");

    iFetchErrors.Reset();

    }

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

// ErrorCount

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

//

TInt CGlxFetchErrorArray::ErrorCount() const

    {

    TRACER("CGlxFetchErrorArray::ErrorCount");

    return iFetchErrors.Count();

    }

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

// Error

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

//

TGlxFetchError CGlxFetchErrorArray::Error(TInt aIndex) const

    {

    TRACER("CGlxFetchErrorArray::Error");

    return iFetchErrors[aIndex];

    }

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

// AddErrorL

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

//

void CGlxFetchErrorArray::AddErrorL(TGlxFetchError aError)

    {

    TRACER("CGlxFetchErrorArray::AddErrorL");

    TInt index = FindError(aError.iAttr);

    if ( KErrNotFound == index )

        {

    	TLinearOrder<TGlxFetchError> orderer (&ErrorOrderById);

        iFetchErrors.InsertInOrderL(aError, orderer);

        }

    else

        {

        iFetchErrors[index] = aError;

        }

    }

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

// Remove an error

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

//

void CGlxFetchErrorArray::Remove( TInt aIndex )

    {

    TRACER("CGlxFetchErrorArray::Remove");

    iFetchErrors.Remove( aIndex );

    }

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

// FindError

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

//

TInt CGlxFetchErrorArray::FindError(TMPXAttribute aAttr) const

    {

    TRACER("CGlxFetchErrorArray::FindError");

    return iFetchErrors.FindInOrder(aAttr, (&ErrorOrderByKey));

    }

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

// FindError

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

//    

TInt CGlxFetchErrorArray::FindError(TInt aContentId) const

    {

    TRACER("CGlxFetchErrorArray::FindError");

    TInt count = iFetchErrors.Count();

    TInt pos = KErrNotFound;

    for(TInt i=0; i<count; i++)

        {

        if(iFetchErrors[i].iAttr.ContentId()==aContentId)

            {

            pos = i;

            break;

            }      

        }

    return pos;

    }

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

// ErrorOrderByKey

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

//

TInt CGlxFetchErrorArray::ErrorOrderByKey(const TMPXAttribute* aAttr, const TGlxFetchError& aItem2) 

	{

	TRACER("CGlxFetchErrorArray::ErrorOrderByKey");

	TInt contentId1 = aAttr->ContentId();

	TInt contentId2 = aItem2.iAttr.ContentId();

	if (contentId1 < contentId2) 

		{

		return -1;

		}

	if (contentId1 > contentId2) 

		{

		return 1;

		}

    TUint attributeId1 = aAttr->AttributeId();

    TUint attributeId2 = aItem2.iAttr.AttributeId();

	if (attributeId1 < attributeId2) 

		{

		return -1;

		}

	if (attributeId1 > attributeId2) 

		{

		return 1;

		}

	return 0;

	}

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

// ErrorOrderById

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

//

TInt CGlxFetchErrorArray::ErrorOrderById(const TGlxFetchError& aItem1, const TGlxFetchError& aItem2) 

	{

	TRACER("CGlxFetchErrorArray::ErrorOrderById");

	return ErrorOrderByKey(&(aItem1.iAttr), aItem2);

	}