/*

* Copyright (c) 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:  Source file for CUpnpFilePipe class.

*

*/

// INCLUDE FILES

#include "upnpfilepipe.h"

_LIT( KComponentLogfile, "upnpcommand.log");

#include "upnplog.h"

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

// CUpnpFilePipe::NewL

// Creates a new file pipe with unlimited length.

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

//

CUpnpFilePipe* CUpnpFilePipe::NewL()

    {

    __LOG( "[UpnpCommand]\t CUpnpFilePipe::NewL" );

    // Create a new file pipe with unlimited length (0).

    return new (ELeave) CUpnpFilePipe( 0 );

    }

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

// CUpnpFilePipe::NewL

// Creates a new file pipe with a set length.

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

//

CUpnpFilePipe* CUpnpFilePipe::NewL( TInt aMaxSize )

    {

    __LOG( "[UpnpCommand]\t CUpnpFilePipe::NewL" );

    // Check param

    if( aMaxSize <= 0 )

        {

        User::Leave( KErrArgument );

        }

    // Create a new file pipe with the given length.

    return new (ELeave) CUpnpFilePipe( aMaxSize );

    }

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

// CUpnpFilePipe::CUpnpFilePipe

// First phase construction.

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

//

CUpnpFilePipe::CUpnpFilePipe( TInt aMaxSize )

    : iMaxSize( aMaxSize )

    {

    // No implementation

    }

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

// Destructor.

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

//

CUpnpFilePipe::~CUpnpFilePipe()

    {

    __LOG( "[UpnpCommand]\t CUpnpFilePipe::Destructor" );

    // Reset the content of the array

    Reset();

    // Close the array

    iValues.Close();

    }

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

// CUpnpFilePipe::PushL

// Pushes one file into the pipe.

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

//

void CUpnpFilePipe::PushL( const TDesC& aParam )

    {

    __LOG( "[UpnpCommand]\t CUpnpFilePipe::PushL" );

    // Parameter check

    if( aParam == KNullDesC )

        {

        User::Leave( KErrArgument );

        }

    // If we are using a pipe with a limited size

    if( iMaxSize > 0 )

        {

        // If the pipe is already full (max size reached) remove the newest

        // file from the pipe

        if( iValues.Count() >= iMaxSize )

            {

            RemoveNewestFileFromPipe();

            }

        }

    // Create a new parameter value

    HBufC* temp = aParam.AllocL();

    CleanupStack::PushL( temp );

    // Append the new parameter value to the array

    iValues.AppendL( temp );

    // Just pop, ownership transfered to iValues array

    CleanupStack::Pop( temp ); 

    }

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

// CUpnpFilePipe::FileAt

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

//

const TDesC& CUpnpFilePipe::FileAt( TInt aIndex )

    {

    __ASSERTD( aIndex >= 0 && aIndex < iValues.Count(),

        __FILE__, __LINE__ );

    TDesC* file = iValues[aIndex];

    return *file;

    }

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

// CUpnpFilePipe::Reset

// Resets the pipe.

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

//

void CUpnpFilePipe::Reset()

    {

    __LOG( "[UpnpCommand]\t CUpnpFilePipe::Reset" );

    // Simply reset the array

    iValues.ResetAndDestroy();

    }

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

// CUpnpFilePipe::Count

// Returns the count of the items in the pipe.

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

//

TInt CUpnpFilePipe::Count()

    {

    __LOG( "[UpnpCommand]\t CUpnpFilePipe::Count" );

    // Simply retun the array's item count

    return iValues.Count();

    }

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

// CUpnpFilePipe::AsArray

// returns the entire pipe as an array

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

//

RPointerArray<TDesC>& CUpnpFilePipe::AsArray()

    {

    return iValues;

    }

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

// CUpnpFilePipe::RemoveNewestFileFromPipe

// Removes the newest file from the pipe.

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

//

void CUpnpFilePipe::RemoveNewestFileFromPipe()

    {

    __LOG( "[UpnpCommand]\t CUpnpFilePipe::RemoveNewestFileFromPipe" );

    // Remove item only if there are items in the pipe

    if( iValues.Count() > 0 )

        {

        // Get the index of the newest item (last item in the array)

        TInt newestIndex = iValues.Count() - 1; // indexing starts from 0

        // Get the pointer to the data, and delete it

        HBufC* temp = static_cast<HBufC*>( iValues[newestIndex] );

        delete temp;

        temp = NULL;

        // Remove the pointer from the array, this will also compress the

        // array

        iValues.Remove( newestIndex );

        }

    }

// End of file