1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 #include <s32mem.h>

    18 #include "tsserializeddataprovider.h"

    19 #include "tsmodel.h"

    20 // -----------------------------------------------------------------------------

    21 /**

    22  * Leaving constructor. 

    23  * @param observer - data observer

    24  */

    25 CTsSerializedDataProvider* CTsSerializedDataProvider::NewL(MTsDataObserver &observer)

    26 {

    27     return new (ELeave) CTsSerializedDataProvider(observer);

    28     

    29 }

    30 

    31 // -----------------------------------------------------------------------------

    32 /**

    33  * Constructor

    34  * @param observer - data observer

    35  */

    36 CTsSerializedDataProvider::CTsSerializedDataProvider(MTsDataObserver& observer)

    37 :

    38     mObserver(observer)

    39 {}

    40 

    41 // -----------------------------------------------------------------------------

    42 /**

    43  * Destructor

    44  */

    45 CTsSerializedDataProvider::~CTsSerializedDataProvider()

    46 {

    47     mData.Close();

    48 }

    49 

    50 // -----------------------------------------------------------------------------

    51 /**

    52  * Interface implementation.

    53  * @see MTsDataProvider::Data()

    54  */

    55 const TDesC8& CTsSerializedDataProvider::Data() const

    56 {

    57     return mData;

    58 }

    59 

    60 // -----------------------------------------------------------------------------

    61 /**

    62  * Interface implementation.

    63  * @see MTsModelObserver::dataChanged(MTsModel &)

    64  */

    65 void CTsSerializedDataProvider::dataChanged(MTsModel &model)

    66 {

    67     serializeModel(model);

    68 }

    69 

    70 // -----------------------------------------------------------------------------

    71 /**

    72  * Interface implementation.

    73  * @see MTsModelObserver::dataChanged(TTsModelItem &)

    74  */

    75 void CTsSerializedDataProvider::dataChanged(const TTsModelItem &/*item*/)

    76 {

    77     //No implementation required now. 

    78 }

    79 

    80 // -----------------------------------------------------------------------------

    81 /**

    82  * Serialize source model into internal data storage

    83  * @param src - model

    84  */

    85 void CTsSerializedDataProvider::serializeModel(const MTsModel &src)

    86 {

    87     TRAPD(errNo, serializeModelL(src));

    88     if(KErrNone == errNo ) {

    89         mObserver.DataChanged();

    90     }

    91 }

    92 

    93 // -----------------------------------------------------------------------------

    94 /**

    95  * Serialize source model into internal data storage. Function can leave.

    96  * @param src - source model

    97  */

    98 void CTsSerializedDataProvider::serializeModelL(const MTsModel &src)

    99 {

   100     const TInt KExpandSize = 256;

   101     CBufFlat* buf = CBufFlat::NewL(KExpandSize);

   102     CleanupStack::PushL(buf);

   103     RBufWriteStream stream(*buf); 

   104     CleanupClosePushL(stream);

   105     

   106     serializeModelL(stream, src);

   107     

   108     CleanupStack::PopAndDestroy(&stream);

   109     mData.Close();

   110     mData.CreateL(buf->Size());

   111     buf->Read(0, mData, buf->Size());

   112     CleanupStack::PopAndDestroy(buf);

   113 }

   114 

   115 // -----------------------------------------------------------------------------

   116 /**

   117  * Serialize source model into destination stream. Function can leave.

   118  * @param dst - destination stream

   119  * @param src - source model

   120  */

   121 void CTsSerializedDataProvider::serializeModelL(RWriteStream& dst, const MTsModel &src)

   122 {

   123     dst.WriteInt32L(src.count());

   124     for (TInt iter(0); iter < src.count(); ++iter) {

   125         dst << src.itemL(iter);

   126     }

   127 }