/*
* Copyright (c) 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:  Implementation of the CVoiceMailboxEntry class
*
*/

// INCLUDE FILES
#include <cvoicemailboxentry.h>
#include "vmbxlogger.h"

// CONSTANTS

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

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::NewL
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CVoiceMailboxEntry* CVoiceMailboxEntry::NewL()
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::NewL =>" );
    CVoiceMailboxEntry* self = CVoiceMailboxEntry::NewLC();
    CleanupStack::Pop( self );
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::NewL <=" );
    return self;
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::NewLC
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CVoiceMailboxEntry* CVoiceMailboxEntry::NewLC()
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::NewLC =>" );
    CVoiceMailboxEntry* self = new( ELeave ) CVoiceMailboxEntry;
    CleanupStack::PushL( self );
    self->ConstructL();
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::NewLC <=" );
    return self;
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::~CVoiceMailboxEntry
// Destructor
// ---------------------------------------------------------------------------
//
CVoiceMailboxEntry::~CVoiceMailboxEntry()
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::~CVoiceMailboxEntry =>" );
    delete ivmbxNumber;
    delete iVmbxBrandId;
    delete ivmbxName;
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::~CVoiceMailboxEntry <=" );
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::ServiceId
// Get ServiceId
// ---------------------------------------------------------------------------
//
EXPORT_C TServiceId CVoiceMailboxEntry::ServiceId() const
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::ServiceId =>" );
    VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::ServiceId:\
    ServiceId=%d <=", iVmbxServiceId );
    return iVmbxServiceId;
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::SetServiceId
// Set entry's service id
// ---------------------------------------------------------------------------
//
void CVoiceMailboxEntry::SetServiceId( 
                        const TServiceId& aVmbxServiceId )
    {
    VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::SetServiceId: ServiceId=%d =>",
    aVmbxServiceId );
    iVmbxServiceId = aVmbxServiceId;
    VMBLOGSTRING( "VMBX: CVoiceMailboxImpl::SetServiceId <=" );
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::VoiceMailboxType
// Returns type of the entry instance
// ---------------------------------------------------------------------------
//
EXPORT_C TVmbxType CVoiceMailboxEntry::VoiceMailboxType( ) const
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::VoiceMailboxType <=>" );
    return iVmbxType;
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::SetVoiceMailboxType
// Set Type of the entry instance
// ---------------------------------------------------------------------------
//
EXPORT_C void CVoiceMailboxEntry::SetVoiceMailboxType( const TVmbxType& aType )
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::SetVoiceMailboxType =>" );
    iVmbxType = aType;
    VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::SetVoiceMailboxType:\
    iVmbxType=%d <=", iVmbxType );
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::VmbxAlsLineType
// Get ALS line Type of the entry instance
// ---------------------------------------------------------------------------
//
EXPORT_C TVmbxAlsLineType CVoiceMailboxEntry::VmbxAlsLineType() const
    {
    VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::VmbxAlsLineType:\
    iVmbxLineType=%d <=>", iVmbxLineType );
    return iVmbxLineType;
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::SetVmbxAlsLineType
// Set ALS line Type of the entry instance
// ---------------------------------------------------------------------------
//
void CVoiceMailboxEntry::SetVmbxAlsLineType( 
                                const TVmbxAlsLineType& aLine )
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::SetVmbxAlsLineType =>" );
    if ( EVmbxAlsLineDefault == aLine  )
        {
        iVmbxLineType = EVmbxAlsLine1;
        }
    else
        {
        iVmbxLineType = aLine;
        }
    VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::SetVmbxAlsLineType:\
    iVmbxLineType=%d <=", iVmbxLineType );
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::GetVmbxNumber
// Get number or address of the entry instance
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CVoiceMailboxEntry::GetVmbxNumber( TPtrC& aVmbxNumber ) const
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::GetVmbxNumber =>" );
    TInt result( KErrNotFound );
    if ( ivmbxNumber )
        {
        aVmbxNumber.Set( ivmbxNumber->Des() );
        VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::GetVmbxNumber:\
        ivmbxNumber = %S", &aVmbxNumber );
        result = KErrNone;
        }
    else
        {
        VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::GetVmbxNumber:KNullDesC" );
        aVmbxNumber.Set( KNullDesC );
        }
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::GetVmbxNumber <=" );
    return result;
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::SetVmbxNumber
// Set number or address of the entry instance
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CVoiceMailboxEntry::SetVmbxNumber( const TDesC& aVmbxNumber )
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::SetVmbxNumber =>" );
    TInt result( KErrNoMemory );
    if ( aVmbxNumber.Length() > KVmbxMaxNumberLength )
        {
        result = KErrOverflow;
        }
    else
        {
        delete ivmbxNumber;
        ivmbxNumber = aVmbxNumber.Alloc(); // Returns NULL if fails.
        if ( ivmbxNumber )
            {
            result = KErrNone;
            VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::SetVmbxNumber:\
            ivmbxNumber = %S", ivmbxNumber );
            }
        }
    VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::SetVmbxNumber:\
    result = %I<=", result ); 
    return result;
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::GetVmbxAlsLineType
// Get Brand Id of the entry instance
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CVoiceMailboxEntry::GetBrandId( TPtrC8& aBrandId ) const
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::GetBrandId =>" );
    TInt result( KErrNotFound );
    if ( iVmbxBrandId )
        {
        aBrandId.Set( iVmbxBrandId->Des() );
        result = KErrNone;
        }
    else
        {
        aBrandId.Set( KNullDesC8 );
        }
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::GetBrandId <=" );
    return result;
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::SetBrandId
// Set Brand Id of the entry instance
// ---------------------------------------------------------------------------
//
TInt CVoiceMailboxEntry::SetBrandId( const TDesC8& aBrandId )
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::SetBrandId =>" );
    TInt result( KErrNoMemory );
    if ( KVmbxMaxNumberLength < aBrandId.Length() )
        {
        result = KErrArgument;
        }
    else
        {
        delete iVmbxBrandId;
        iVmbxBrandId = aBrandId.Alloc();
        if ( iVmbxBrandId )
            {
            result = KErrNone;
            VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::SetBrandId:\
            iVmbxBrandId = %S", iVmbxBrandId );
            }
        }
    VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::SetBrandId:result = %d <=",
    result );
    return result;
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::GetVmbxName
// Get Name of the entry instance
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CVoiceMailboxEntry::GetVmbxName( TPtrC& aVmbxName ) const
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::GetVmbxName =>" );
    TInt result( KErrNotFound );
    if ( ivmbxName )
        {
        aVmbxName.Set( ivmbxName->Des() );
        VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::GetVmbxName:\
        ivmbxName = %S", &aVmbxName );
        result = KErrNone;
        }
    else
        {
        VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::GetVmbxName:KNullDesC" );
        aVmbxName.Set( KNullDesC );
        }      
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::GetVmbxName <=" );
    return result;
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::SetVmbxName
// Set Name of the entry instance
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CVoiceMailboxEntry::SetVmbxName( const TDesC& aVmbxName )
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::SetVmbxName =>" );
    TInt result( KErrNoMemory );
    if ( KVmbxMaxNumberLength < aVmbxName.Length() )
        {
        result = KErrOverflow;
        }
    else
        {
        delete ivmbxName;
        ivmbxName = aVmbxName.Alloc(); // Returns NULL if fails.
        if ( ivmbxName )
            {
            result = KErrNone;
            VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::SetVmbxName:\
            ivmbxName = %S", ivmbxName );
            }       
        }
    VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::SetVmbxName: result %d <=", 
                    result );
    return result;
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::UsingMemoryLocation
// Returns memory location of the entry instance
// ---------------------------------------------------------------------------
//
EXPORT_C TVmbxMemoryLocation CVoiceMailboxEntry::UsingMemoryLocation( ) const
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::UsingMemoryLocation <=>" );
    return iUsingMemory;
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::Reset
// Reset the data members of the entry instance
// ---------------------------------------------------------------------------
//
EXPORT_C void CVoiceMailboxEntry::Reset()
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::Reset =>" );
    iVmbxServiceId = KVmbxServiceIdNone;
    iVmbxType = EVmbxNone;
    iVmbxLineType = EVmbxAlsLineDefault;
    if ( ivmbxNumber )
    	{
    	ivmbxNumber->Des().Zero();
    	VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::Reset vmbx number" );
    	}
    if ( ivmbxName )
    	{
    	ivmbxName->Des().Zero();
    	VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::Reset vmbx name" );
    	}
    if ( iVmbxBrandId )
    	{
    	iVmbxBrandId->Des().Zero();
    	VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::Reset vmbx brandId" );
    	}
    iUsingMemory = EVmbxSimMemory;
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::Reset <=" );
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::SetUsingMemoryLocation
// Set using memory of the entry instance
// ---------------------------------------------------------------------------
//
void CVoiceMailboxEntry::SetUsingMemoryLocation( 
                                        const TVmbxMemoryLocation& aType  )
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::SetUsingMemoryLocation =>" );
    iUsingMemory = aType;
    VMBLOGSTRING2( "VMBX: CVoiceMailboxEntry::SetUsingMemoryLocation:\
    iUsingMemory=%I <=", iUsingMemory );
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::CVoiceMailboxEntry
// C++ default constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------------------------
//
CVoiceMailboxEntry::CVoiceMailboxEntry()
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::CVoiceMailboxEntry <=>" );
    }

// ---------------------------------------------------------------------------
// CVoiceMailboxEntry::ConstructL
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CVoiceMailboxEntry::ConstructL()
    {
    VMBLOGSTRING( "VMBX: CVoiceMailboxEntry::ConstructL <=>" );
    }

// End of file