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 

    18 

    19 

    20 

    21 

    22 

    23 

    24 

    25 

    26 #include "policyreferenceassertion.h"

    27 #include "wspolicyregistry.h"

    28 #include "policyassertion.h"

    29 #include "wspolicyreader.h"

    30 CPolicyReferenceAssertion* CPolicyReferenceAssertion::NewL(TDesC8& aUri)

    31 {

    32     CPolicyReferenceAssertion* pSelf = CPolicyReferenceAssertion::NewLC(aUri);

    33     CleanupStack::Pop(pSelf);

    34     return pSelf;

    35     

    36 }

    37 CPolicyReferenceAssertion* CPolicyReferenceAssertion::NewLC(TDesC8& aUri)

    38 {

    39     CPolicyReferenceAssertion* pSelf = new (ELeave) CPolicyReferenceAssertion();

    40     CleanupStack::PushL(pSelf);

    41     pSelf->ConstructL(aUri);

    42     return pSelf;

    43     

    44 }

    45 CPolicyReferenceAssertion* CPolicyReferenceAssertion::NewL(CPolicyReferenceAssertion* aValue)

    46 {

    47     CPolicyReferenceAssertion* pSelf = CPolicyReferenceAssertion::NewLC(aValue);

    48     CleanupStack::Pop(pSelf);

    49     return pSelf;

    50     

    51 }

    52 CPolicyReferenceAssertion* CPolicyReferenceAssertion::NewLC(CPolicyReferenceAssertion* aValue)

    53 {

    54     CPolicyReferenceAssertion* pSelf = new (ELeave) CPolicyReferenceAssertion();

    55     CleanupStack::PushL(pSelf);

    56     pSelf->ConstructL(aValue);

    57     return pSelf;

    58     

    59 }

    60 CPolicyReferenceAssertion::~CPolicyReferenceAssertion()

    61 {

    62     delete iUri;    

    63 }

    64 CPolicyReferenceAssertion::CPolicyReferenceAssertion()

    65 :iUri(NULL)

    66 {

    67     

    68 }

    69 void CPolicyReferenceAssertion::ConstructL(TDesC8& aUri)

    70 {

    71     if(aUri.Length() > 0)

    72     {

    73         iUri = aUri.AllocL();

    74     }

    75 }

    76 TPtrC8 CPolicyReferenceAssertion::PolicyUri()

    77 {

    78     if(iUri && iUri->Length() > 0)

    79     {

    80         TPtrC8 p = iUri->Des();

    81         return p;

    82     }

    83     else

    84     {

    85         return KNullDesC8();

    86     }

    87 }

    88 

    89 void CPolicyReferenceAssertion::ConstructL(CPolicyReferenceAssertion* aValue)

    90 {

    91     if(aValue->PolicyUri().Length() > 0)

    92     {

    93         TPtrC8 uri = aValue->PolicyUri();

    94         ConstructL(uri);

    95     }

    96 }

    97 void CPolicyReferenceAssertion::AddTerm(MAssertion* /*aAssertion*/)

    98 {

    99     

   100 }

   101 void CPolicyReferenceAssertion::AddTerms(RPolicyTerms& /*aAssertions*/)

   102 {

   103     

   104 }

   105 void CPolicyReferenceAssertion::AddTermCopyL(MAssertion* /*aAssertion*/)

   106 {

   107     

   108 }

   109 void CPolicyReferenceAssertion::AddTermsCopyL(RPolicyTerms& /*aAssertions*/)

   110 {

   111     

   112 }

   113 void CPolicyReferenceAssertion::MoveTermL(RPolicyTerms& /*aAssertions*/)

   114 {

   115     

   116 }

   117 void CPolicyReferenceAssertion::MoveTermsL(RPolicyTerms& /*aAssertions*/)

   118 {

   119     

   120 }

   121 MAssertion* CPolicyReferenceAssertion::GetParent()

   122 {

   123   return NULL;  

   124 }

   125 TBool CPolicyReferenceAssertion::HasParent()

   126 {

   127     return EFalse;

   128 }

   129 TBool CPolicyReferenceAssertion::IsEmpty()

   130 {

   131     return ETrue;

   132 }

   133 TBool CPolicyReferenceAssertion::IsNormalized()

   134 {

   135     return EFalse;

   136 }

   137 TBool CPolicyReferenceAssertion::Remove(MAssertion* /*aAssertion*/)

   138 {

   139     return EFalse;

   140 }

   141 void CPolicyReferenceAssertion::SetNormalized(TBool /*aFlag*/)

   142 {

   143     

   144 }

   145 void CPolicyReferenceAssertion::SetParent(MAssertion* /*aParent*/)

   146 {

   147     

   148 }

   149 TInt CPolicyReferenceAssertion::Size()

   150 {

   151     return KErrNone;

   152 }

   153 TAssertionType  CPolicyReferenceAssertion::Type()

   154 {

   155     return EPolicyReferenceType;    

   156 }

   157 

   158 MAssertion* CPolicyReferenceAssertion::IntersectL(MAssertion* /*aAssertion*/, CPolicyRegistry* /*aRegistry*/)

   159 {

   160     return NULL;

   161 }

   162 MAssertion* CPolicyReferenceAssertion::IntersectL(MAssertion* /*aAssertion*/)

   163 {

   164     return NULL;

   165 }

   166 MAssertion* CPolicyReferenceAssertion::MergeL(MAssertion* /*aAssertion*/, CPolicyRegistry* /*aRegistry*/)

   167 {

   168     return NULL;

   169 }

   170 MAssertion* CPolicyReferenceAssertion::MergeL(MAssertion* /*aAssertion*/)

   171 {

   172     return NULL;

   173 }

   174 MAssertion* CPolicyReferenceAssertion::NormalizeL(CPolicyRegistry* aRegistry)

   175 {

   176     if (aRegistry == NULL) 

   177     {

   178         return NULL;

   179     }

   180 

   181     _LIT8(KHash, "#");

   182     HBufC8* pRippedUri = NULL;	//CodeScannerWarnings

   183     MAssertion* result = NULL;

   184     

   185     TPtrC8 uri = PolicyUri();

   186     

   187     if(uri.Left(1).Compare(KHash) == 0)

   188     {

   189         pRippedUri = uri.Right(uri.Length()-1).AllocL(); 

   190         CleanupStack::PushL(pRippedUri);

   191         if(pRippedUri->Length() > 0)

   192         {

   193             

   194             CSenElement* targetPolicy = aRegistry->LookupPolicy(pRippedUri->Des());

   195             if (targetPolicy == NULL)

   196             {

   197                 result = NULL;;

   198             }

   199             else

   200             {

   201                 CWSPolicyReader* reader = CWSPolicyReader::NewLC();

   202                 CPolicyAssertion* policy = reader->GetPolicyL(targetPolicy);

   203                 CleanupStack::PopAndDestroy();

   204                 CleanupStack::PushL( policy );

   205                 result = policy->NormalizeL( aRegistry );

   206                 CleanupStack::PopAndDestroy( policy );

   207             }

   208             

   209         }

   210         CleanupStack::PopAndDestroy(pRippedUri);

   211     }

   212     return result;

   213 

   214 }

   215 MAssertion* CPolicyReferenceAssertion::NormalizeL()

   216 {

   217     return NULL;

   218 }