1 /*

     2 * Copyright (c) 2002-2005 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 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 // INCLUDE FILES 

    26 #include "SenSoapFault.h"

    27 #include "SenSoapEnvelope.h"

    28 

    29 EXPORT_C CSenSoapFault* CSenSoapFault::NewL(const TDesC8& aNsUri,

    30                                             const TDesC8& aLocalName,

    31                                             const TDesC8& aQName,

    32                                             const RAttributeArray& aAttributes)

    33     {

    34     CSenSoapFault* pNew = new (ELeave) CSenSoapFault;

    35     CleanupStack::PushL(pNew);

    36     pNew->ConstructL(aNsUri, aLocalName, aQName, aAttributes);

    37     CleanupStack::Pop(); // pNew;

    38     return pNew;

    39     }

    40 

    41 EXPORT_C CSenSoapFault* CSenSoapFault::NewL(CSenElement& aCopiedSource)

    42     {

    43     CSenSoapFault* pNew = new (ELeave) CSenSoapFault;

    44     CleanupStack::PushL(pNew);

    45     pNew->ConstructL(aCopiedSource);

    46     CleanupStack::Pop(); // pNew;

    47     return pNew;

    48     }

    49 

    50 

    51 EXPORT_C CSenSoapFault::~CSenSoapFault()

    52     {

    53     }

    54 

    55 EXPORT_C CSenSoapFault::CSenSoapFault()

    56     {

    57     }

    58 

    59 EXPORT_C void CSenSoapFault::ConstructL(CSenElement& aCopiedSource)

    60     {

    61     BaseConstructL(aCopiedSource.LocalName());

    62     CopyFromL(aCopiedSource);

    63     }

    64 

    65 

    66 EXPORT_C void CSenSoapFault::ConstructL(const TDesC8& aNsUri,

    67                              const TDesC8& aLocalName,

    68                              const TDesC8& aQName,

    69                              const RAttributeArray& aAttributes)

    70     {

    71     BaseConstructL(aNsUri, aLocalName, aQName, aAttributes);

    72     }

    73 EXPORT_C TPtrC8 CSenSoapFault::FaultCode()

    74     {

    75         if (NamespaceURI().Compare(KSenSoap12EnvelopeXmlns)!=0)

    76         {

    77                 

    78             CSenElement* pChild = Element(KNullDesC8, KFaultCodeLocalname);

    79             if(pChild)

    80                 {

    81                 return pChild->Content();

    82                 }

    83         }

    84         else

    85         {

    86             CSenElement* pChild = Element(KFault12CodeLocalname);

    87             if (pChild)

    88             {

    89                 CSenElement* pValue = pChild->Element(KFault12ValueLocalname);

    90                 if (pValue)

    91                 {

    92                     return pValue->Content();

    93                 }

    94             }

    95             

    96         }

    97         return KNullDesC8();

    98     }

    99 

   100 EXPORT_C TPtrC8 CSenSoapFault::FaultSubcode()

   101     {

   102         if (NamespaceURI().Compare(KSenSoap12EnvelopeXmlns)==0)

   103         {

   104             CSenElement* pChild = Element(KFault12CodeLocalname);

   105             if (pChild)

   106             {

   107                 CSenElement* pSubcode = pChild->Element(KFault12SubcodeLocalname);

   108                 if (pSubcode)

   109                 {

   110                     CSenElement* pValue = pSubcode->Element(KFault12ValueLocalname);

   111                     if (pValue)

   112                     {

   113                         return pValue->Content();

   114                     }

   115                 }

   116             }

   117             

   118         }

   119         return KNullDesC8();

   120     }

   121 

   122 

   123 EXPORT_C TPtrC8 CSenSoapFault::FaultString()

   124     {

   125         if (NamespaceURI().Compare(KSenSoap12EnvelopeXmlns)!=0)

   126         {

   127             CSenElement* pChild = Element(KNullDesC8, KFaultStringLocalname);

   128             if(pChild)

   129                 {

   130                 return pChild->Content();

   131                 }

   132         }

   133         else

   134         {

   135             CSenElement* pChild = Element(KNullDesC8, KFault12ReasonLocalname);

   136             if (pChild)

   137             {

   138                 CSenElement* pText = pChild->Element(KFault12TextLocalname);

   139                 if (pText)

   140                 {

   141                     return pText->Content();

   142                 }

   143             }

   144         }

   145     return KNullDesC8();    

   146     }

   147 

   148 EXPORT_C TPtrC8 CSenSoapFault::FaultActor()

   149     {

   150     CSenElement* pChild = Element(KNullDesC8, KFaultActorLocalname);

   151     if(pChild)

   152         {

   153         return pChild->Content();

   154         }

   155     return KNullDesC8();    

   156     }

   157 

   158 EXPORT_C TPtrC8 CSenSoapFault::Detail()

   159     {

   160         if (NamespaceURI().Compare(KSenSoap12EnvelopeXmlns)!=0)

   161         {

   162             CSenElement* pChild = Element(KNullDesC8, KDetailLocalname);

   163             if(pChild)

   164                 {

   165                 return pChild->Content();

   166                 }

   167         }

   168         else

   169         {

   170             CSenElement* pChild = Element(KFault12DetailLocalname);

   171             if (pChild)

   172             {

   173                     return pChild->Content();

   174             }

   175         }

   176     return KNullDesC8();    

   177     }

   178 

   179 // End of File