/*

* Copyright (c) 2004 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:  Datatype for the X-Oma header data

*

*/

// INCLUDE FILES

#include <s32strm.h>

#include "DRMXOma.h"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CDRMXOma::NewLC

// Two-phased constructor.

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

//

CDRMXOma* CDRMXOma::NewLC( const TDesC8& aContentID,

                           const TTime& aTimeStamp,

                           const TTimeIntervalSeconds& aWaitTime )

    {

    CDRMXOma* self = new( ELeave ) CDRMXOma( aTimeStamp, aWaitTime );

    CleanupStack::PushL( self );

    self->ConstructL( aContentID );

    return self;    

    };

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

// CDRMXOma::NewL

// Two-phased constructor.

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

//

CDRMXOma* CDRMXOma::NewL( const TDesC8& aContentID,

                          const TTime& aTimeStamp,

                          const TTimeIntervalSeconds& aWaitTime )

    {

    CDRMXOma* self = NewLC( aContentID, 

                            aTimeStamp, aWaitTime );

    CleanupStack::Pop();

    return self;

    };        

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

// CDRMXOma::NewLC

// Two-phased constructor.

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

//

CDRMXOma* CDRMXOma::NewLC()

    {

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

    CleanupStack::PushL( self );

    return self;    

    };

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

// CDRMXOma::NewL

// Two-phased constructor.

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

//

CDRMXOma* CDRMXOma::NewL()

    {

    CDRMXOma* self = NewLC();

    CleanupStack::Pop();

    return self;

    };          

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

// Default Constructor - First phase.

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

//

CDRMXOma::CDRMXOma( const TTime& aTimeStamp, 

                   const TTimeIntervalSeconds& aWaitTime ) :

    iTimeStamp( aTimeStamp ),

    iWaitTime( aWaitTime )

    {

    }; 

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

// Default Constructor - First phase.

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

//

CDRMXOma::CDRMXOma()

    {

    }; 

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

// Destructor

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

//

CDRMXOma::~CDRMXOma()

    {

    if( iContentID )

        {

        delete iContentID;

        iContentID = NULL;

        }        

    };

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

// CDRMXOma::ContentID

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

//        

const TDesC8& CDRMXOma::ContentID() const

    {

    return *iContentID;

    };

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

// CDRMXOma::TimeStamp

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

//    

const TTime& CDRMXOma::TimeStamp() const

    {

    return iTimeStamp;

    };

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

// CDRMXOma::WaitTime

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

//    

const TTimeIntervalSeconds& CDRMXOma::WaitTime() const

    {

    return iWaitTime;

    };

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

// CDRMXOma::SetContentIDL

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

//         

void CDRMXOma::SetContentIDL( const TDesC8& aContentID )

    {

    HBufC8* newContentID = aContentID.AllocL();

    if( iContentID )

        {

        delete iContentID;

        iContentID = NULL;

        }

    iContentID = newContentID;    

    };

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

// CDRMXOma::SetTimeStampL

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

//         

void CDRMXOma::SetTimeStampL( const TTime& aTimeStamp )

    {

    iTimeStamp = aTimeStamp;    

    };    

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

// CDRMXOma::SetWaitTimeL

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

//         

void CDRMXOma::SetWaitTimeL( const TTimeIntervalSeconds& aWaitTime )

    {

    iWaitTime = aWaitTime;    

    }; 

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

// CDRMXOma::ExternalizeL

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

// 

void CDRMXOma::ExternalizeL( RWriteStream& aStream ) const

    {

    TInt dataLength = 0;

    // Write the ContentID

    dataLength = 0;

    if( iContentID )

        {

        dataLength = iContentID->Length();

        }

    aStream.WriteInt32L( dataLength );

    if( dataLength )

        {

        aStream.WriteL( iContentID->Des() );        

        }

    // Write the time stamp

    WriteInt64L( iTimeStamp.Int64(), aStream );

    // write the wait time

    aStream.WriteInt32L( iWaitTime.Int() );

    };

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

// CDRMXOma::InternalizeL

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

// 

void CDRMXOma::InternalizeL( RReadStream& aStream )

    {

    TInt64 timeData = 0;    

    TInt dataLength = 0;

    HBufC8* dataPart = 0;

    TPtr8 dataBuffer(NULL,0,0);

    TPtr16 dataBuffer2(NULL,0,0);

    // Read the ContentID

    dataLength = aStream.ReadInt32L();

    if( dataLength )

        {

        // Reserve a new buffer:

        dataPart = HBufC8::NewMaxLC( dataLength );

        // Set the read buffer:

        dataBuffer.Set(const_cast<TUint8*>(dataPart->Ptr()), 0, dataLength);

        // Read the data:

        aStream.ReadL( dataBuffer );

        // Pop the buffer 

        CleanupStack::Pop(); // dataPart

        // If an old content identifier exists delete it        

        if( iContentID )

            {

            delete iContentID;

            iContentID = NULL;

            }

        // assign the new content id

        iContentID = dataPart;    

        }

    else

        {

        // If an old content identifier exists delete it 

        if( iContentID )

            {

            delete iContentID;

            iContentID = NULL;

            }        

        }           

    // The Time stamp

    ReadInt64L( timeData, aStream );

    iTimeStamp = timeData;    

    // The time interval                

    iWaitTime =  aStream.ReadInt32L();               

    };   

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

// CDRMXOma::Size

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

// 

TInt CDRMXOma::Size() const

    {

    TInt size = 0;

    // Content identifier of the content

    size += sizeof(TInt32);

    if( iContentID )

        {

        size += iContentID->Size();

        }

    // Issuer of the rights

    size += sizeof(TTime);

    // Content name

    size += sizeof(TTimeIntervalSeconds);

    return size;

    };    

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

// CDRMXOma::ConstructL

// Second phase constructor

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

// 

void CDRMXOma::ConstructL( const TDesC8& aContentID )

    {

    iContentID = aContentID.AllocL();

    };                

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

// CDRMXOma::WriteInt64L

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

//

void CDRMXOma::WriteInt64L( const TInt64& aWrite, RWriteStream& aStream ) const

    {

    TPtr8 output( reinterpret_cast<TUint8*>(const_cast<TInt64*>(&aWrite)), 

                  sizeof(TInt64), sizeof(TInt64) );

    aStream.WriteL( output, sizeof(TInt64) );

    }

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

// CCDRMXOma::ReadInt64L

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

//

void CDRMXOma::ReadInt64L( TInt64& aRead, RReadStream& aStream )

    {

    TPtr8 input( reinterpret_cast<TUint8*>(&aRead), 0, sizeof(TInt64) );

    aStream.ReadL( input, sizeof(TInt64) );    

    };

// End of File