httpfilters/cookie/ManagerSrc/CookieGroupDataArray.cpp
branchRCL_3
changeset 7 2611c08ee28e
child 18 5f1cd966e0d9
equal deleted inserted replaced
6:fa2fd8b2d6cc 7:2611c08ee28e
       
     1 /*
       
     2  * CCookieGroupDataArray.cpp
       
     3  *
       
     4  *  Created on: Nov 24, 2009
       
     5  *      Author: mohanti
       
     6  */
       
     7 //System Includes
       
     8 #include <e32cmn.h>
       
     9 #include <e32base.h>
       
    10 
       
    11 //User Includes
       
    12 #include "CookieGroupDataArray.h"
       
    13 #include "CookieGroupData.h"
       
    14 #include "GroupIdInfoArray.h"
       
    15 #include "CookieArray.h"
       
    16 #include "CookieLogger.h"
       
    17 
       
    18 //Constatnts
       
    19 const TInt KCookieArrayGranularity = 10;
       
    20 
       
    21 
       
    22 
       
    23 // ---------------------------------------------------------
       
    24 // CCookieGroupDataArray::NewL
       
    25 // ---------------------------------------------------------
       
    26 //
       
    27 
       
    28 CCookieGroupDataArray* CCookieGroupDataArray::NewL()
       
    29     {
       
    30     CCookieGroupDataArray* self = CCookieGroupDataArray::NewLC();
       
    31     CleanupStack::Pop();
       
    32     return self;
       
    33     }
       
    34 
       
    35 // ---------------------------------------------------------
       
    36 // CCookieGroupDataArray::NewLC
       
    37 // ---------------------------------------------------------
       
    38 //
       
    39 
       
    40 CCookieGroupDataArray* CCookieGroupDataArray::NewLC()
       
    41     {
       
    42     CCookieGroupDataArray* self = new (ELeave) CCookieGroupDataArray();
       
    43     CleanupStack::PushL(self);
       
    44     self->ConstructL();
       
    45     return self;
       
    46     }
       
    47 
       
    48 // ---------------------------------------------------------
       
    49 // CCookieGroupDataArray::ConstructL
       
    50 // ---------------------------------------------------------
       
    51 //
       
    52 
       
    53 void CCookieGroupDataArray::ConstructL()
       
    54     {
       
    55     CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray::ConstructL" ) ) );
       
    56     iCookieGroupData = new (ELeave) RPointerArray<CCookieGroupData>(KCookieArrayGranularity);
       
    57     CLOG( ( EClient, 0, _L( "<- CCookieGroupDataArray::ConstructL" ) ) );
       
    58     }
       
    59 
       
    60 // ---------------------------------------------------------
       
    61 // CCookieGroupDataArray::CCookieGroupDataArray
       
    62 // ---------------------------------------------------------
       
    63 //
       
    64 
       
    65 CCookieGroupDataArray::CCookieGroupDataArray()
       
    66     {
       
    67     CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray::CCookieGroupDataArray" ) ) );
       
    68     CLOG( ( EClient, 0, _L( "<- CCookieGroupDataArray::CCookieGroupDataArray" ) ) );
       
    69     }
       
    70 // ---------------------------------------------------------
       
    71 // CCookieGroupDataArray::~CCookieGroupDataArray
       
    72 // ---------------------------------------------------------
       
    73 //
       
    74 
       
    75 CCookieGroupDataArray::~CCookieGroupDataArray()
       
    76     {
       
    77     CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray::~CCookieGroupDataArray" ) ) );
       
    78     if(iCookieGroupData && Count())
       
    79         {
       
    80          iCookieGroupData->ResetAndDestroy();
       
    81          iCookieGroupData->Close();
       
    82          //delete iCookieGroupData;
       
    83          iCookieGroupData = NULL;
       
    84         }
       
    85     CLOG( ( EClient, 0, _L( "<- CCookieGroupDataArray::~CCookieGroupDataArray" ) ) );
       
    86     }
       
    87 // ---------------------------------------------------------
       
    88 // CCookieGroupDataArray::Count
       
    89 // ---------------------------------------------------------
       
    90 //
       
    91 TInt CCookieGroupDataArray::Count()const
       
    92     {
       
    93     return iCookieGroupData->Count(); 
       
    94     }
       
    95 
       
    96 // ---------------------------------------------------------
       
    97 // CCookieGroupDataArray::FindIndex
       
    98 // ---------------------------------------------------------
       
    99 //
       
   100 TInt CCookieGroupDataArray::FindIndex(TUint32 aGroupId,TInt& aIndex )
       
   101     {
       
   102     CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray::FindIndex aGroupId = %x" ), aGroupId ) );
       
   103     TInt count = Count();
       
   104     CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray::count = %d" ), count ) );
       
   105     for(TInt i=0;i<count;i++)
       
   106         {
       
   107         CCookieGroupData* p = At(i);
       
   108         if( p->GetGroupId() == aGroupId)
       
   109             {
       
   110             aIndex=i;
       
   111             CLOG( ( EClient, 0, _L( "<- CCookieGroupDataArray::FindIndex found for GroupId %x with Index = %d" )
       
   112                     , aGroupId,aIndex ) );
       
   113             return KErrNone;
       
   114             }
       
   115         }
       
   116      CLOG( ( EClient, 0, _L( "<- CCookieGroupDataArray::FindIndex NotFound for GroupId %x with Index = %d" )
       
   117              , aGroupId ,aIndex) );    
       
   118      return KErrNotFound;
       
   119     }
       
   120 
       
   121 // ---------------------------------------------------------
       
   122 // CCookieGroupDataArray::FindIndex
       
   123 // ---------------------------------------------------------
       
   124 //
       
   125 TInt CCookieGroupDataArray::FindIndex(TUint32 aGroupId,TUint32 aAppUid,TInt& aIndex )
       
   126     {
       
   127     CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray::FindIndex aGroupId = %x,aAppUid = %x" ), aGroupId, aAppUid ) );
       
   128     TInt count = Count();
       
   129     for(TInt i=0;i<count;i++)
       
   130         {
       
   131         CCookieGroupData* p = At(i);
       
   132         TInt appCount = p->TotalAppUid();
       
   133         TInt appUidFound(EFalse);
       
   134         if( p->GetGroupId() == aGroupId)
       
   135             {
       
   136              for(TInt j=0; j<appCount; j++)
       
   137                  {
       
   138                   if (p->GetSharedUid(j)== aAppUid)
       
   139                       appUidFound = ETrue;
       
   140                   break;
       
   141                  }
       
   142              if (appUidFound)
       
   143                  {
       
   144                  aIndex=i;
       
   145                  return KErrNone;
       
   146                  }
       
   147             }
       
   148         }
       
   149      return KErrNotFound;
       
   150     }
       
   151 
       
   152 // ---------------------------------------------------------
       
   153 // CCookieGroupDataArray::Compress
       
   154 // ---------------------------------------------------------
       
   155 //
       
   156 void CCookieGroupDataArray::AddGroupDataL(CCookieGroupData* aCcookieGroupData)
       
   157     {
       
   158     CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray::AddGroupDataL" ) ) );
       
   159     iCookieGroupData->AppendL(aCcookieGroupData);
       
   160     CLOG( ( EClient, 0, _L( "<- CCookieGroupDataArray::AddGroupDataL" ) ) );
       
   161     }
       
   162 
       
   163 // ---------------------------------------------------------
       
   164 // CCookieGroupDataArray::Compress
       
   165 // ---------------------------------------------------------
       
   166 //
       
   167 void CCookieGroupDataArray::Compress()
       
   168     {
       
   169     iCookieGroupData->Compress();
       
   170     }
       
   171 
       
   172 
       
   173 // ---------------------------------------------------------
       
   174 // CCookieGroupDataArray::operator[]
       
   175 // ---------------------------------------------------------
       
   176 //
       
   177 CCookieGroupData* CCookieGroupDataArray::operator[](TInt aIndex) const
       
   178     {
       
   179     return (*iCookieGroupData)[aIndex];
       
   180     }
       
   181 
       
   182   // ---------------------------------------------------------
       
   183   // CCookieGroupDataArray::GetGroupData
       
   184   // ---------------------------------------------------------
       
   185   //
       
   186 CCookieGroupData* CCookieGroupDataArray::At(TInt aIndex) const
       
   187     {
       
   188     return (*iCookieGroupData)[ aIndex ];
       
   189     }
       
   190 
       
   191 // ---------------------------------------------------------
       
   192 // CCookieGroupDataArray::GetGroupData
       
   193 // ---------------------------------------------------------
       
   194 //
       
   195 CCookieGroupData* CCookieGroupDataArray::GetGroupData(TInt aIndex)
       
   196     {
       
   197     return(At(aIndex));
       
   198     }
       
   199 
       
   200 // ---------------------------------------------------------
       
   201 // CCookieGroupDataArray::GetGroupDataIndexL
       
   202 // ---------------------------------------------------------
       
   203 //
       
   204 void CCookieGroupDataArray::GetGroupDataIndexL(TUint32 aGroupId,TUint32 aAppUid,TBool& aCookieSharableFlag, TInt& aIndex)
       
   205     {
       
   206      CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray::GetGroupDataIndexL aGroupId = %x, aAppUid = %x" ), aGroupId, aAppUid ) );
       
   207      TInt count = Count();
       
   208      TBool found(EFalse);
       
   209      CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray::GetGroupDataIndexL count = %d" ), count ) );
       
   210      if ( count == 0 )
       
   211          {
       
   212          RArray<TUint32> appUidArray(1);
       
   213          appUidArray.Append(aAppUid);
       
   214          CCookieGroupData* cookiegroupdata = CCookieGroupData::NewL(aGroupId,appUidArray,aCookieSharableFlag);
       
   215          CleanupStack::PushL( cookiegroupdata );
       
   216          AddGroupDataL(cookiegroupdata);
       
   217          aIndex = 0;
       
   218          CleanupStack::Pop(cookiegroupdata);
       
   219          appUidArray.Close();
       
   220          } else {
       
   221                 
       
   222                 TInt totalappUid = iCookieGroupData->Count();
       
   223                 for ( TInt i=0; i<count; i++ )
       
   224                    {
       
   225                     CCookieGroupData* cookiegroupdata = At(i);
       
   226                     if ( cookiegroupdata->GetGroupId() == aGroupId && !(cookiegroupdata->GetCookieSharableFlag()) )
       
   227                       {
       
   228                       found = ETrue;
       
   229                       aIndex = i;
       
   230                       break;
       
   231                       }else if (cookiegroupdata->GetGroupId() == aGroupId && (cookiegroupdata->GetCookieSharableFlag()))
       
   232                           {
       
   233                            TBool groupMatch(ETrue);
       
   234                            TBool sharedUidMatch(EFalse);
       
   235                            TInt total = cookiegroupdata->TotalAppUid();
       
   236                            for(TInt j=0;j<total;j++)
       
   237                               {
       
   238                                if (cookiegroupdata->GetSharedUid(j)== aAppUid)
       
   239                                    {
       
   240                                        sharedUidMatch = ETrue;
       
   241                                        break;
       
   242                                    }
       
   243                               }
       
   244                            if (groupMatch || sharedUidMatch)
       
   245                                {
       
   246                                found = ETrue;
       
   247                                aIndex = i;
       
   248                                break;
       
   249                                }
       
   250                           }
       
   251                           
       
   252                         
       
   253                    CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray::GetGroupDataIndexL aGroupId %x and aAppUid %x found at index %d" ), aGroupId, aAppUid, aIndex ) );
       
   254                       }
       
   255                     }
       
   256                if(!found)
       
   257                 {
       
   258                  RArray<TUint32> appUidArray(1);
       
   259                  appUidArray.Append(aAppUid);
       
   260                  CCookieGroupData* cookiegroupdata = CCookieGroupData::NewL(aGroupId, appUidArray, aCookieSharableFlag);
       
   261                  CleanupStack::PushL( cookiegroupdata );
       
   262                  AddGroupDataL(cookiegroupdata);
       
   263                  TInt total = Count();
       
   264                  aIndex = total-1;
       
   265                  CleanupStack::Pop(cookiegroupdata);
       
   266                  appUidArray.Close();
       
   267                 }
       
   268      CLOG( ( EClient, 0, _L( "<- CCookieGroupDataArray::GetGroupDataIndexL" ) ) );
       
   269     }
       
   270 
       
   271 // ---------------------------------------------------------
       
   272 // CCookieGroupDataArray::CookieArray
       
   273 // ---------------------------------------------------------
       
   274 //
       
   275 CCookieArray* CCookieGroupDataArray::CookieArray(TInt aIndex)
       
   276     {
       
   277     CCookieGroupData* cookiegroupdata = At(aIndex);
       
   278     return cookiegroupdata->CookieArray();
       
   279     }
       
   280 
       
   281 // ---------------------------------------------------------
       
   282 // CCookieGroupDataArray::GetCookies
       
   283 // ---------------------------------------------------------
       
   284 //
       
   285 TInt CCookieGroupDataArray::GetCookies( const TDesC8& aRequestUri,
       
   286                                       RPointerArray<CCookie>& aCookies,TInt aIndex ) const
       
   287     {
       
   288     CCookieArray* cookieArray = At(aIndex)->CookieArray();
       
   289     return cookieArray->GetCookies( aRequestUri, aCookies );
       
   290     }
       
   291 
       
   292 // ---------------------------------------------------------
       
   293 // CCookieGroupDataArray::Remove
       
   294 // ---------------------------------------------------------
       
   295 //
       
   296 void CCookieGroupDataArray::Remove(TInt aIndex)
       
   297     {
       
   298     CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray:: Remove %d" ), aIndex ) );
       
   299     delete (*iCookieGroupData)[ aIndex ];
       
   300     iCookieGroupData->Remove(aIndex);
       
   301     iCookieGroupData->Compress();
       
   302     CLOG( ( EClient, 0, _L( "<- CCookieGroupDataArray::Remove " ) ) );
       
   303     }
       
   304 
       
   305 // ---------------------------------------------------------
       
   306 // CCookieGroupDataArray::DestroyGroupData
       
   307 // ---------------------------------------------------------
       
   308 //
       
   309 TInt CCookieGroupDataArray::DestroyGroupData(TUint32 aGroupId)
       
   310     {
       
   311     CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray::DestroyGroupData aGroupId = %x" ), aGroupId ) );
       
   312     TInt count = Count();
       
   313     CLOG( ( EClient, 0, _L( "-> CCookieGroupDataArray::DestroyGroupData count = %d" ), count ) );
       
   314     if (count == 0)
       
   315         {
       
   316          return KErrNotFound;
       
   317         }
       
   318     
       
   319     TBool found(EFalse);
       
   320     for (TInt i=0; i<count; i++)
       
   321         {
       
   322         CCookieGroupData* cookiegroupdata = At(i);
       
   323         if ( cookiegroupdata->GetGroupId() == aGroupId)
       
   324             {
       
   325             found = ETrue;
       
   326             Remove(i);
       
   327             --i;
       
   328             --count;
       
   329             CLOG( ( EClient, 0, _L( "<- CCookieGroupDataArray::DestroyGroupData aGroupId = %x removed from Array" ), aGroupId ) );
       
   330             }
       
   331         }
       
   332     if ( found )
       
   333         return KErrNone;
       
   334 	else
       
   335 		return KErrNotFound;
       
   336     }