1 /*

     2 * Copyright (c) 2006-2008 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:   CNcdDependencyInfo

    15 *

    16 */

    17 

    18 

    19 #include <s32strm.h>

    20 

    21 #include "ncddependencyinfo.h"

    22 #include "ncdnodeidentifier.h"

    23 #include "catalogsutils.h"

    24 

    25 

    26 CNcdDependencyInfo* CNcdDependencyInfo::NewL( const TDesC& aName, 

    27                                               const TDesC& aVersion, 

    28                                               const TDesC& aUid,

    29                                               CNcdNodeIdentifier* aIdentifier )

    30     {

    31     CNcdDependencyInfo* self = 

    32         CNcdDependencyInfo::NewLC( aName, aVersion, aUid, aIdentifier );

    33     CleanupStack::Pop( self );

    34     return self;            

    35     }

    36     

    37 CNcdDependencyInfo* CNcdDependencyInfo::NewLC( const TDesC& aName, 

    38                                                const TDesC& aVersion, 

    39                                                const TDesC& aUid,

    40                                                CNcdNodeIdentifier* aIdentifier )

    41     {

    42     CleanupStack::PushL( aIdentifier ); 

    43     CNcdDependencyInfo* self = 

    44         new( ELeave ) CNcdDependencyInfo( aIdentifier );

    45     CleanupStack::Pop( aIdentifier );

    46     CleanupStack::PushL( self );

    47     self->ConstructL( aName, aVersion, aUid );

    48     return self;            

    49     }

    50 

    51 void CNcdDependencyInfo::ConstructL( const TDesC& aName, 

    52                                      const TDesC& aVersion, 

    53                                      const TDesC& aUid )

    54     {

    55     DLTRACEIN((""));

    56 

    57     TInt uid( 0 );

    58     

    59     // Error is ignored on purpose, if the given text doesn't contain

    60     // a hex int then uid is set a 0

    61     TRAP_IGNORE( uid = DesHexToIntL( aUid ) );

    62     DLTRACE(( _L("aUid: %S was converted to %x"), &aUid, uid ));

    63     iUid.iUid = uid;

    64 

    65     iName = aName.AllocL();

    66     iVersion = aVersion.AllocL();        

    67     }

    68 

    69 

    70 CNcdDependencyInfo* CNcdDependencyInfo::NewL( const TDesC& aName, 

    71                                               const TDesC& aVersion, 

    72                                               TUid aUid,

    73                                               CNcdNodeIdentifier* aIdentifier )

    74     {

    75     CNcdDependencyInfo* self = 

    76         CNcdDependencyInfo::NewLC( aName, aVersion, aUid, aIdentifier );

    77     CleanupStack::Pop( self );

    78     return self;            

    79     }

    80     

    81 CNcdDependencyInfo* CNcdDependencyInfo::NewLC( const TDesC& aName, 

    82                                                const TDesC& aVersion, 

    83                                                TUid aUid,

    84                                                CNcdNodeIdentifier* aIdentifier )

    85     {

    86     CleanupStack::PushL( aIdentifier );    

    87     CNcdDependencyInfo* self = 

    88         new( ELeave ) CNcdDependencyInfo( aIdentifier );

    89     CleanupStack::Pop( aIdentifier );

    90     CleanupStack::PushL( self );

    91     self->ConstructL( aName, aVersion, aUid );

    92     return self;            

    93     }

    94 

    95 void CNcdDependencyInfo::ConstructL( const TDesC& aName, 

    96                                      const TDesC& aVersion, 

    97                                      TUid aUid )

    98     {

    99     DLTRACEIN(("aUid: %x", aUid.iUid));

   100     

   101     iUid.iUid = aUid.iUid;

   102 

   103     iName = aName.AllocL();

   104     iVersion = aVersion.AllocL();

   105     }

   106 

   107 

   108 CNcdDependencyInfo* CNcdDependencyInfo::NewL( RReadStream& aReadStream )

   109     {

   110     CNcdDependencyInfo* self = 

   111         CNcdDependencyInfo::NewLC( aReadStream );

   112     CleanupStack::Pop( self );

   113     return self;            

   114     }

   115     

   116 CNcdDependencyInfo* CNcdDependencyInfo::NewLC( RReadStream& aReadStream )

   117     {

   118     CNcdDependencyInfo* self = 

   119         new( ELeave ) CNcdDependencyInfo( NULL );

   120     CleanupStack::PushL( self );

   121     self->ConstructL( aReadStream );

   122     return self;            

   123     }

   124 

   125 void CNcdDependencyInfo::ConstructL( RReadStream& aReadStream )

   126     {

   127     InternalizeL( aReadStream );

   128     }

   129 

   130 

   131 CNcdDependencyInfo::CNcdDependencyInfo( CNcdNodeIdentifier* aIdentifier ): 

   132     CBase(), 

   133     iIdentifier( aIdentifier ),

   134     iDependencyState( ENcdDependencyMissing )

   135     {

   136     

   137     }

   138     

   139 CNcdDependencyInfo::~CNcdDependencyInfo()

   140     {

   141     delete iName;

   142     delete iVersion;

   143     delete iIdentifier;

   144     }

   145 

   146 

   147 const TDesC& CNcdDependencyInfo::Name() const

   148     {

   149     return *iName;

   150     }    

   151 

   152 const TDesC& CNcdDependencyInfo::Version() const

   153     {

   154     return *iVersion;

   155     }

   156     

   157 TUid CNcdDependencyInfo::Uid() const

   158     {

   159     return iUid;

   160     }

   161 

   162 

   163 const CNcdNodeIdentifier* CNcdDependencyInfo::Identifier() const

   164     {

   165     return iIdentifier;

   166     }

   167 

   168 

   169 void CNcdDependencyInfo::SetDependencyState( TNcdDependencyState aState )

   170     {

   171     DLTRACEIN(("aState: %d", aState));

   172     iDependencyState = aState;

   173     }

   174 

   175 

   176 TNcdDependencyState CNcdDependencyInfo::DependencyState() const

   177     {

   178     DLTRACEIN(("Current state: %d", iDependencyState));

   179     return iDependencyState;

   180     }

   181 

   182 

   183 void CNcdDependencyInfo::InternalizeL( RReadStream& aReadStream )

   184     {

   185     DLTRACEIN((""));

   186     InternalizeDesL( iName, aReadStream );

   187     InternalizeDesL( iVersion, aReadStream );

   188     iUid.iUid = aReadStream.ReadInt32L();

   189     delete iIdentifier;

   190     iIdentifier = NULL;

   191     

   192     if ( aReadStream.ReadInt8L() )

   193         {

   194         iIdentifier = CNcdNodeIdentifier::NewL( aReadStream );

   195         }

   196         

   197     iDependencyState = static_cast<TNcdDependencyState>( 

   198         aReadStream.ReadInt32L() );

   199     }

   200     

   201 

   202 void CNcdDependencyInfo::ExternalizeL( RWriteStream& aWriteStream ) const

   203     {

   204     DLTRACEIN((""));

   205     ExternalizeDesL( Name(), aWriteStream );

   206     ExternalizeDesL( Version(), aWriteStream );

   207     aWriteStream.WriteInt32L( Uid().iUid );

   208     if ( Identifier() == NULL )

   209         {

   210         aWriteStream.WriteInt8L( EFalse );

   211         }

   212     else

   213         {

   214         aWriteStream.WriteInt8L( ETrue );

   215         Identifier()->ExternalizeL( aWriteStream );

   216         }

   217     aWriteStream.WriteInt32L( iDependencyState );

   218     }