/*
* 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:      Light weight version of UpnpObject
*
*/






#include "upnpobjectlite.h"

const TInt KDelimeter = 46;
const TInt KRound1 = 1;
const TInt KRound2 = 2;
const TInt KRound3 = 3; 
const TInt KRound4 = 4;

const TInt KMask1 = 0xFF000000;
const TInt KMask2 = 0x00FF0000;

_LIT8( KObject, "object" );
_LIT8( KItem, "item" );
_LIT8( KContainer,"container" );

_LIT8( KImageItem, "imageItem" );
_LIT8( KAudioItem, "audioItem" );
_LIT8( KVideoItem, "videoItem" );
_LIT8( KPlaylistItem, "playlistItem" );
_LIT8( KStorageFolder, "storageFolder" );
_LIT8( KPlaylistContainer, "playlistContainer" );

_LIT8( KMusicTrack,"musicTrack" );
_LIT8( KPhoto,"photo" );
_LIT8( KVideo,"video" );
_LIT8( KMusicAlbum,"musicAlbum" );


// --------------------------------------------------------------------------
// CUpnpObjectLite::CUpnpObjectLite
// See upnpobjectlite.h
// --------------------------------------------------------------------------
CUpnpObjectLite::CUpnpObjectLite()
    {
    }

// --------------------------------------------------------------------------
// CUpnpObjectLite::~CUpnpObjectLite
// See upnpobjectlite.h
// --------------------------------------------------------------------------
EXPORT_C CUpnpObjectLite::~CUpnpObjectLite()
    {
    delete iObjectId;
    delete iTitle;
    }

// --------------------------------------------------------------------------
// CUpnpObjectLite::NewL
// See upnpobjectlite.h
// --------------------------------------------------------------------------
void CUpnpObjectLite::ConstructL()
    {
    
    }

// --------------------------------------------------------------------------
// CUpnpObjectLite::NewL
// See upnpobjectlite.h
// --------------------------------------------------------------------------
EXPORT_C CUpnpObjectLite* CUpnpObjectLite::NewL()
    {
    CUpnpObjectLite* self = new (ELeave) CUpnpObjectLite();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }
    
// --------------------------------------------------------------------------
// CUpnpObjectLite::SetObjectIdL
// See upnpobjectlite.h
// --------------------------------------------------------------------------
EXPORT_C void CUpnpObjectLite::SetObjectIdL( const TDesC8& aObjectId )
    {
    HBufC8* tmp = aObjectId.AllocL();
    delete iObjectId;
    iObjectId = tmp;
    }

    
// --------------------------------------------------------------------------
// CUpnpObjectLite::SetObjectIdL
// See upnpobjectlite.h
// --------------------------------------------------------------------------
EXPORT_C void CUpnpObjectLite::SetObjectIdL( HBufC8* aObjectId )
    {
    if( aObjectId )
        {
        delete iObjectId;
        iObjectId = aObjectId;
        }
    else
        {
        User::Leave( KErrArgument );
        }    
    }
    
// --------------------------------------------------------------------------
// CUpnpObjectLite::ObjectId
// See upnpobjectlite.h
// --------------------------------------------------------------------------
EXPORT_C const TDesC8& CUpnpObjectLite::ObjectId() const
    {
    if( iObjectId )
        {
        return *iObjectId;
        }
    else
        {
        return KNullDesC8;
        }    
    }

// --------------------------------------------------------------------------
// CUpnpObjectLite::SetTitleL
// See upnpobjectlite.h
// --------------------------------------------------------------------------
EXPORT_C void CUpnpObjectLite::SetTitleL( const TDesC& aTitle )
    {
    HBufC* tmp = aTitle.AllocL();
    delete iTitle;
    iTitle = tmp;    
    }
    
// --------------------------------------------------------------------------
// CUpnpObjectLite::SetTitleL
// See upnpobjectlite.h
// --------------------------------------------------------------------------
EXPORT_C void CUpnpObjectLite::SetTitleL( HBufC* aTitle )
    {
    if( aTitle )
        {
        delete iTitle;
        iTitle = aTitle;
        }
    else
        {
        User::Leave( KErrArgument );
        }        
    }
    
// --------------------------------------------------------------------------
// CUpnpObjectLite::Title
// See upnpobjectlite.h
// --------------------------------------------------------------------------
EXPORT_C const TDesC& CUpnpObjectLite::Title() const
    {
    if( iTitle )
        {
        return *iTitle;
        }
    else
        {
        return KNullDesC;
        }        
    }
    
// --------------------------------------------------------------------------
// CUpnpObjectLite::SetObjectClass
// See upnpobjectlite.h
// --------------------------------------------------------------------------
EXPORT_C void CUpnpObjectLite::SetObjectClass( const TDesC8& aObjectClass )
    {
    iObjectClass = 0;
    TInt round = 0;
    
    TLex8 input( aObjectClass );
    while( !input.Eos() )
        {
        round++;
        ParseToDelimeter( input, TChar( KDelimeter ) );
        
        HandleRound( round, input.MarkedToken() );

        if( !input.Eos() )
            {
            input.SkipAndMark( 1 ); // Skip the delimeter
            }
        }
    
    }
    
// --------------------------------------------------------------------------
// CUpnpObjectLite::IsTypeOf
// See upnpobjectlite.h
// --------------------------------------------------------------------------
EXPORT_C TBool CUpnpObjectLite::IsTypeOf( TObjectType aType ) const
    {
    TBool retVal = EFalse;
    switch( aType )
        {
        case EItem:
            {
            if( ( iObjectClass & KMask1 ) == EBaseItem )
                {
                retVal = ETrue;
                }
            }
            break;
        case EContainer:
            {
            if( ( iObjectClass & KMask1 ) == EBaseContainer )
                {
                retVal = ETrue;
                }            
            }
            break;
        case EMusicItem:
            {
            if( ( iObjectClass & KMask2 ) == EBaseMusicItem )
                {
                retVal = ETrue;
                }                                    
            }
            break;
        case EImageItem:
            {
            if( ( iObjectClass & KMask2 ) == EBaseImageItem )
                {
                retVal = ETrue;
                }                                    
            }
            break;
        case EVideoItem:
            {
            if( ( iObjectClass & KMask2 ) == EBaseVideoItem )
                {
                retVal = ETrue;
                }                                                
            }
            break;
        default:
            {
            retVal = EFalse;                                               
            }
            break;
        }
    
    return retVal;
    }

// --------------------------------------------------------------------------
// CUpnpObjectLite::ParseToDelimeter
// See upnpobjectlite.h
// --------------------------------------------------------------------------
void CUpnpObjectLite::ParseToDelimeter( TLex8& aLex, TChar aDelimeter ) const
    {
    aLex.Mark();
    while( (aLex.Peek() != aDelimeter) && (!aLex.Eos()) )
        {
        aLex.Inc();
        }
    }

// --------------------------------------------------------------------------
// CUpnpObjectLite::HandleRound
// See upnpobjectlite.h
// --------------------------------------------------------------------------
void CUpnpObjectLite::HandleRound( TInt aRound, TPtrC8 aString )
    {
    switch( aRound )
        {
        case KRound1:
            {
            Round1( aString );
            break;
            }
        case KRound2:
            {
            Round2( aString );
            break;
            }
        case KRound3:
            {
            Round3( aString );
            break;
            }
        case KRound4:
            {
            Round4( aString );
            break;
            }
            
        default:
            {
            
            break;
            }
        }
    }

void CUpnpObjectLite::Round1( TPtrC8 aString )
    {
    if( aString.Compare( KObject ) != 0 )
        {
        // Not an object
        iObjectClass |= EBaseUnknown;
        }
    }
    
void CUpnpObjectLite::Round2( TPtrC8 aString )
    {
    if( aString.Compare( KItem ) == 0 )
        {
        iObjectClass |= EBaseItem;
        }
    else if( aString.Compare( KContainer ) == 0 )
        {
        iObjectClass |= EBaseContainer;
        }
    else
        {
        iObjectClass |= EBaseUnknown;
        }    
    }
    
void CUpnpObjectLite::Round3( TPtrC8 aString )
    {
    if( aString.Compare( KImageItem ) == 0 )
        {
        iObjectClass |= EBaseImageItem;
        }
    else if( aString.Compare( KAudioItem ) == 0 )
        {
        iObjectClass |= EBaseMusicItem;
        }
    else if( aString.Compare( KVideoItem ) == 0 )
        {
        iObjectClass |= EBaseVideoItem;
        }
    else if( aString.Compare( KPlaylistItem ) == 0 )
        {
        iObjectClass |= EBasePlaylistItem;
        }    
    else if( aString.Compare( KStorageFolder ) == 0 )
        {
        iObjectClass |= EStorageFolder;
        }    
    else if( aString.Compare( KPlaylistContainer ) == 0 )
        {
        iObjectClass |= EPlaylistContainer;
        }
    else
        {
        
        }        
    }
    
void CUpnpObjectLite::Round4( TPtrC8 aString )
    {
    if( aString.Compare( KMusicTrack ) == 0 )
        {
        iObjectClass |= EMusicTrack;
        }
    else if( aString.Compare( KPhoto ) == 0 )
        {
        iObjectClass |= EPhoto;
        }
    else if( aString.Compare( KVideo ) == 0 )
        {
        iObjectClass |= EMovie;
        }
    else if( aString.Compare( KMusicAlbum ) == 0 )
        {
        iObjectClass |= EMusicAlbum;
        }    
    else
        {
        
        }            
    }

// end of file