1 /*

     2 * Copyright (c) 2005-2006 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 the License "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:    Contains CIptvVodDlDownloadEvent objects*

    15 */

    16 

    17 

    18 

    19 

    20 

    21 // INCLUDE FILES

    22 #include "CIptvVodDlDownloadEvents.h"

    23 #include "CIptvVodDlDownloadEvent.h"

    24 #include <s32mem.h>

    25 

    26 // EXTERNAL DATA STRUCTURES

    27 

    28 // EXTERNAL FUNCTION PROTOTYPES  

    29 

    30 // CONSTANTS

    31 

    32 // MACROS

    33 

    34 // LOCAL CONSTANTS AND MACROS

    35 

    36 // MODULE DATA STRUCTURES

    37 

    38 // LOCAL FUNCTION PROTOTYPES

    39 

    40 // FORWARD DECLARATIONS

    41 

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

    43 

    44 

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

    46 

    47 // -----------------------------------------------------------------------------

    48 // CIptvVodDlDownloadEvents::CIptvVodDlDownloadEvents

    49 // C++ default constructor can NOT contain any code, that

    50 // might leave.

    51 // -----------------------------------------------------------------------------

    52 //

    53 CIptvVodDlDownloadEvents::CIptvVodDlDownloadEvents()

    54     {

    55     }

    56 

    57 // -----------------------------------------------------------------------------

    58 // CIptvVodDlDownloadEvents::ConstructL

    59 // Symbian 2nd phase constructor can leave.

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

    61 //

    62 void CIptvVodDlDownloadEvents::ConstructL()

    63     {

    64     iEvents.Reset();

    65     }

    66 

    67 // -----------------------------------------------------------------------------

    68 // CIptvVodDlDownloadEvents::NewL

    69 // Two-phased constructor.

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

    71 //

    72 EXPORT_C CIptvVodDlDownloadEvents* CIptvVodDlDownloadEvents::NewL()

    73     {

    74     CIptvVodDlDownloadEvents* self = new( ELeave ) CIptvVodDlDownloadEvents;

    75     

    76     CleanupStack::PushL( self );

    77     self->ConstructL();

    78     CleanupStack::Pop(self);

    79 

    80     return self;

    81     }

    82 

    83     

    84 // Destructor

    85 EXPORT_C CIptvVodDlDownloadEvents::~CIptvVodDlDownloadEvents()

    86     {

    87     DeleteEvents();

    88     }

    89 

    90 

    91 // -----------------------------------------------------------------------------

    92 // CIptvVodDlDownloadEvents::InternalizeL

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

    94 //

    95 EXPORT_C void CIptvVodDlDownloadEvents::InternalizeL(RReadStream& aStream)

    96     {

    97     TUint16 eventCount = aStream.ReadUint16L();

    98     TInt i;

    99     for(i = 0; i < eventCount; i++)

   100         {

   101         CIptvVodDlDownloadEvent* event = CIptvVodDlDownloadEvent::NewL();

   102         CleanupStack::PushL(event); // 1->

   103         event->InternalizeL(aStream);

   104         iEvents.AppendL(event);

   105         CleanupStack::Pop(event); // <-1

   106         }

   107     }

   108 

   109 // -----------------------------------------------------------------------------

   110 // CIptvVodDlDownloadEvents::ExternalizeL

   111 // -----------------------------------------------------------------------------

   112 //

   113 EXPORT_C void CIptvVodDlDownloadEvents::ExternalizeL(RWriteStream& aStream)

   114     {

   115     TInt eventCount = iEvents.Count();

   116     aStream.WriteUint16L(eventCount);

   117     TInt i;

   118     for(i = 0; i < eventCount; i++)

   119         {

   120         iEvents[i]->ExternalizeL(aStream);

   121         }

   122     }

   123 

   124 // -----------------------------------------------------------------------------

   125 // CIptvVodDlDownloadEvents::CountExternalizeSize

   126 // -----------------------------------------------------------------------------

   127 //

   128 EXPORT_C TUint32 CIptvVodDlDownloadEvents::CountExternalizeSize()

   129     {

   130     TUint size = 0;

   131     size += 2;

   132     TInt i;

   133     for(i = 0; i < iEvents.Count(); i++)

   134         {

   135         size += iEvents[i]->CountExternalizeSize();

   136         }

   137     return size;

   138     }

   139 

   140 // -----------------------------------------------------------------------------

   141 // CIptvVodDlDownloadEvents::Set

   142 // -----------------------------------------------------------------------------

   143 //    

   144 EXPORT_C void CIptvVodDlDownloadEvents::SetL(CIptvVodDlDownloadEvents& aEvents)

   145     {

   146     DeleteEvents();

   147     

   148     //copy new

   149     TInt i;

   150     for(i = 0; i < aEvents.iEvents.Count(); i++)

   151         {

   152         CIptvVodDlDownloadEvent* event = CIptvVodDlDownloadEvent::NewL();

   153         CleanupStack::PushL(event); // 1->

   154         event->Set(*(aEvents.iEvents[i]));

   155         iEvents.AppendL(event);

   156         CleanupStack::Pop(event); // <-1 

   157         }    

   158     }

   159 

   160 // -----------------------------------------------------------------------------

   161 // CIptvVodDlDownloadEvents::DeleteEvents

   162 // -----------------------------------------------------------------------------

   163 //

   164 EXPORT_C void CIptvVodDlDownloadEvents::DeleteEvents()

   165     {

   166     TInt i;

   167     for(i = 0; i < iEvents.Count(); i++)

   168         {

   169         delete iEvents[i]; //delete data

   170         iEvents[i] = NULL;

   171         } 

   172     iEvents.Close(); //delete pointers

   173     iEvents.Reset();

   174     }

   175        

   176 // ========================== OTHER EXPORTED FUNCTIONS =========================

   177 

   178 

   179 //  End of File