1 /*

     2 * Copyright (c) 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 "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:   Implementation of DevTokenCertInfo

    15 *

    16 */

    17 

    18 

    19 

    20 #include "DevTokenDataTypes.h"

    21 

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

    23 

    24 

    25 // ---------------------------------------------------------------------------

    26 // CDevTokenCertInfo::NewLC(const CDevTokenCertInfo& aOther)

    27 // ---------------------------------------------------------------------------

    28 // 

    29 EXPORT_C CDevTokenCertInfo* CDevTokenCertInfo::NewLC(const CDevTokenCertInfo& aOther)

    30     {

    31     CDevTokenCertInfo* self = NewL(aOther);

    32     CleanupStack::PushL(self);

    33     return self;

    34     }

    35 

    36 

    37 // ---------------------------------------------------------------------------

    38 // CDevTokenCertInfo::NewL(const CDevTokenCertInfo& aOther)

    39 // ---------------------------------------------------------------------------

    40 // 

    41 EXPORT_C CDevTokenCertInfo* CDevTokenCertInfo::NewL(const CDevTokenCertInfo& aOther)

    42     {

    43     return new (ELeave) CDevTokenCertInfo(aOther);

    44     }

    45 

    46 

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

    48 // CDevTokenCertInfo::CDevTokenCertInfo(const CDevTokenCertInfo& aOther)

    49 // ---------------------------------------------------------------------------

    50 //

    51 CDevTokenCertInfo::CDevTokenCertInfo(const CDevTokenCertInfo& aOther) :

    52     MCertInfo(aOther)

    53     {

    54     }

    55 

    56 

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

    58 // CDevTokenCertInfo* CDevTokenCertInfo::NewL()

    59 // ---------------------------------------------------------------------------

    60 //

    61 EXPORT_C CDevTokenCertInfo* CDevTokenCertInfo::NewL(const TDesC& aLabel,

    62                TCertificateFormat aFormat,

    63                TCertificateOwnerType aCertificateOwnerType,

    64                TInt aSize,

    65                const TKeyIdentifier* aSubjectKeyId,   

    66                const TKeyIdentifier* aIssuerKeyId,

    67                TInt aCertificateId)

    68     {

    69     CDevTokenCertInfo* self = new(ELeave) CDevTokenCertInfo(

    70         aLabel,

    71         aFormat, 

    72         aCertificateOwnerType, 

    73         aSize, 

    74         aSubjectKeyId, 

    75         aIssuerKeyId,

    76         aCertificateId);

    77     self->ConstructL(NULL);

    78     return self;

    79     }

    80 

    81 

    82 // ---------------------------------------------------------------------------

    83 // CDevTokenCertInfo* CDevTokenCertInfo::NewL()

    84 // ---------------------------------------------------------------------------

    85 //

    86 EXPORT_C CDevTokenCertInfo* CDevTokenCertInfo::NewL(const TDesC& aLabel,

    87                TCertificateFormat aFormat,

    88                TCertificateOwnerType aCertificateOwnerType,

    89                TInt aSize,

    90                const TKeyIdentifier* aSubjectKeyId,   

    91                const TKeyIdentifier* aIssuerKeyId,

    92                TInt aCertificateId,

    93                const TBool aDeletable)

    94     {

    95     CDevTokenCertInfo* self = new(ELeave) CDevTokenCertInfo(

    96         aLabel,

    97         aFormat, 

    98         aCertificateOwnerType, 

    99         aSize, 

   100         aSubjectKeyId,  

   101         aIssuerKeyId,

   102         aCertificateId, 

   103         aDeletable);

   104     self->ConstructL(NULL);

   105     return self;

   106     }

   107 

   108 

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

   110 // CDevTokenCertInfo* CDevTokenCertInfo::NewLC()

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

   112 //

   113 EXPORT_C CDevTokenCertInfo* CDevTokenCertInfo::NewLC(const TDesC& aLabel,

   114               TCertificateFormat aFormat,

   115               TCertificateOwnerType aCertificateOwnerType,

   116               TInt aSize,

   117               const TKeyIdentifier* aSubjectKeyId,

   118               const TKeyIdentifier* aIssuerKeyId,

   119               TInt aCertificateId)

   120     {

   121     CDevTokenCertInfo* self = CDevTokenCertInfo::NewL(

   122         aLabel,

   123         aFormat, 

   124         aCertificateOwnerType, 

   125         aSize, 

   126         aSubjectKeyId, 

   127         aIssuerKeyId,

   128         aCertificateId);

   129     CleanupStack::PushL(self);

   130     return self;

   131     }

   132 

   133 

   134 // ---------------------------------------------------------------------------

   135 // CDevTokenCertInfo* CDevTokenCertInfo::NewLC()

   136 // ---------------------------------------------------------------------------

   137 //

   138 EXPORT_C CDevTokenCertInfo* CDevTokenCertInfo::NewLC(const TDesC& aLabel,

   139               TCertificateFormat aFormat,

   140               TCertificateOwnerType aCertificateOwnerType,

   141               TInt aSize,

   142               const TKeyIdentifier* aSubjectKeyId,

   143               const TKeyIdentifier* aIssuerKeyId,

   144               TInt aCertificateId,

   145                 const TBool aDeletable)

   146     {

   147     CDevTokenCertInfo* self = CDevTokenCertInfo::NewL(

   148         aLabel,

   149         aFormat, 

   150         aCertificateOwnerType, 

   151         aSize, 

   152         aSubjectKeyId, 

   153         aIssuerKeyId,

   154         aCertificateId, 

   155         aDeletable);

   156     CleanupStack::PushL(self);

   157     return self;

   158     }

   159 

   160 

   161 // ---------------------------------------------------------------------------

   162 // CDevTokenCertInfo::CDevTokenCertInfo()

   163 // ---------------------------------------------------------------------------

   164 //

   165 CDevTokenCertInfo::CDevTokenCertInfo(const TDesC& aLabel, 

   166            TCertificateFormat aFormat,

   167            TCertificateOwnerType aCertificateOwnerType,

   168            TInt aSize,

   169            const TKeyIdentifier* aSubjectKeyId,

   170            const TKeyIdentifier* aIssuerKeyId,

   171            TInt aCertificateId,

   172            const TBool aDeletable) :

   173   MCertInfo(aLabel, aFormat, aCertificateOwnerType, aSize, aSubjectKeyId,

   174         aIssuerKeyId, aCertificateId, aDeletable)

   175     {

   176     }

   177 

   178 

   179 // ---------------------------------------------------------------------------

   180 // CDevTokenCertInfo* CDevTokenCertInfo::NewL(RReadStream& aStream)

   181 // ---------------------------------------------------------------------------

   182 //

   183 EXPORT_C CDevTokenCertInfo* CDevTokenCertInfo::NewL(RReadStream& aStream)

   184     {

   185     CDevTokenCertInfo* me = NewLC(aStream);

   186     CleanupStack::Pop(me);

   187     return me;

   188     }

   189 

   190 

   191 // ---------------------------------------------------------------------------

   192 // CDevTokenCertInfo* CDevTokenCertInfo::NewLC(RReadStream& aStream)

   193 // ---------------------------------------------------------------------------

   194 //

   195 EXPORT_C CDevTokenCertInfo* CDevTokenCertInfo::NewLC(RReadStream& aStream)

   196     {

   197     CDevTokenCertInfo* self = new (ELeave) CDevTokenCertInfo();

   198     CleanupStack::PushL(self);

   199     self->InternalizeL(aStream);

   200     return self;

   201     }

   202 

   203 

   204 // ---------------------------------------------------------------------------

   205 // CDevTokenCertInfo::CDevTokenCertInfo() 

   206 // ---------------------------------------------------------------------------

   207 //

   208 CDevTokenCertInfo::CDevTokenCertInfo() :

   209     MCertInfo()

   210     {

   211     }

   212 

   213 //EOF