Msrp/MsrpHeader/src/CMsrpFromPathHeader.cpp
branchMSRP_FrameWork
changeset 25 505ad3f0ce5c
equal deleted inserted replaced
22:f1578314b8da 25:505ad3f0ce5c
       
     1 /*
       
     2 * Copyright (c) 2009-2010 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 * Initial Contributors:
       
     9 * Nokia Corporation - initial contribution.
       
    10 * Contributors:
       
    11 *
       
    12 * Description:
       
    13 * MSRP Implementation
       
    14 *
       
    15 */
       
    16 
       
    17 // CLASS HEADER
       
    18 #include "CMsrpFromPathHeader.h"
       
    19 
       
    20 // EXTERNAL INCLUDES
       
    21 
       
    22 // INTERNAL INCLUDES
       
    23 #include "MsrpCommon.h"
       
    24 #include "msrpstrings.h"
       
    25 #include "msrpstrconsts.h"
       
    26 
       
    27 // -----------------------------------------------------------------------------
       
    28 // CMSRPFromPathHeader::DecodeL
       
    29 // -----------------------------------------------------------------------------
       
    30 //
       
    31 EXPORT_C CMSRPFromPathHeader* CMSRPFromPathHeader::DecodeL(
       
    32 	const TDesC8& aUri )
       
    33 	{
       
    34 	CMSRPFromPathHeader* self = new (ELeave) CMSRPFromPathHeader();
       
    35     CleanupStack::PushL( self );
       
    36 
       
    37 	// parsing the descriptor URL
       
    38     CUri8* uri = CUri8::NewLC( );
       
    39 	// first is the scheme
       
    40 	TChar charToFind( KColonCharacter );
       
    41 	TInt matchLoc = aUri.Locate( charToFind );
       
    42 	if ( matchLoc != KErrNotFound )
       
    43 		{
       
    44 		TPtrC8 scheme = aUri.Left( matchLoc );
       
    45 		uri->SetComponentL( scheme, EUriScheme );
       
    46 		// after that comes the ipaddress which must have // in front
       
    47 		TPtrC8 host = aUri.Mid( matchLoc + 3 ); // codescanner::magicnumbers
       
    48 		matchLoc = host.Locate( charToFind );
       
    49 		if ( matchLoc != KErrNotFound )
       
    50 			{
       
    51 			uri->SetComponentL( host.Left( matchLoc ), EUriHost );
       
    52 			// next is the port
       
    53 			TPtrC8 port = host.Mid( matchLoc + 1 );
       
    54 			TChar charToFind2( KDividedCharacter );
       
    55 			matchLoc = port.Locate( charToFind2 );
       
    56 			if ( matchLoc != KErrNotFound )
       
    57 				{
       
    58 				uri->SetComponentL( port.Left( matchLoc ), EUriPort );
       
    59 				TPtrC8 path = port.Mid( matchLoc );
       
    60 				uri->SetComponentL( path, EUriPath );
       
    61 				}
       
    62 			else
       
    63 				{
       
    64 				// there is not path set
       
    65 				User::Leave( KErrArgument );
       
    66 				}
       
    67 			}
       
    68 		else
       
    69 			{
       
    70 			User::Leave( KErrArgument );
       
    71 			}
       
    72 		}
       
    73 	else
       
    74 		{
       
    75 		User::Leave( KErrArgument );
       
    76 		}
       
    77 
       
    78     self->ConstructL( uri );
       
    79 	CleanupStack::Pop( uri );
       
    80 	CleanupStack::Pop( self );
       
    81     return self;
       
    82 	}
       
    83 
       
    84 // -----------------------------------------------------------------------------
       
    85 // CMSRPFromPathHeader::NewLC
       
    86 // -----------------------------------------------------------------------------
       
    87 //
       
    88 EXPORT_C CMSRPFromPathHeader* CMSRPFromPathHeader::NewLC(
       
    89 	CUri8* aUri )
       
    90 	{
       
    91 	CMSRPFromPathHeader* self = new (ELeave) CMSRPFromPathHeader();
       
    92     CleanupStack::PushL( self );
       
    93     self->ConstructL( aUri );
       
    94     return self;
       
    95 	}
       
    96 
       
    97 // -----------------------------------------------------------------------------
       
    98 // CMSRPFromPathHeader::NewL
       
    99 // -----------------------------------------------------------------------------
       
   100 //
       
   101 EXPORT_C CMSRPFromPathHeader* CMSRPFromPathHeader::NewL(
       
   102 	CUri8* aUri )
       
   103 	{
       
   104 	CMSRPFromPathHeader* self = CMSRPFromPathHeader::NewLC( aUri );
       
   105 	CleanupStack::Pop( self );
       
   106 	return self;
       
   107 	}
       
   108 
       
   109 // -----------------------------------------------------------------------------
       
   110 // CMSRPFromPathHeader::NewL
       
   111 // -----------------------------------------------------------------------------
       
   112 //
       
   113 CMSRPFromPathHeader* CMSRPFromPathHeader::NewL( )
       
   114 	{
       
   115 	CMSRPFromPathHeader* self = new (ELeave) CMSRPFromPathHeader();
       
   116     CleanupStack::PushL( self );
       
   117     self->ConstructL( );
       
   118 	CleanupStack::Pop( self );
       
   119     return self;
       
   120 	}
       
   121 
       
   122 // -----------------------------------------------------------------------------
       
   123 // CMSRPFromPathHeader::CMSRPFromPathHeader
       
   124 // -----------------------------------------------------------------------------
       
   125 //
       
   126 CMSRPFromPathHeader::CMSRPFromPathHeader()
       
   127     {
       
   128 	}
       
   129 
       
   130 // -----------------------------------------------------------------------------
       
   131 // CMSRPFromPathHeader::~CMSRPFromPathHeader
       
   132 // -----------------------------------------------------------------------------
       
   133 //
       
   134 EXPORT_C CMSRPFromPathHeader::~CMSRPFromPathHeader()
       
   135 	{
       
   136 	MSRPStrings::Close();
       
   137 	}
       
   138 
       
   139 // -----------------------------------------------------------------------------
       
   140 // CMSRPFromPathHeader::ConstructL
       
   141 // -----------------------------------------------------------------------------
       
   142 //
       
   143 void CMSRPFromPathHeader::ConstructL( CUri8* aUri )
       
   144 	{
       
   145 	MSRPStrings::OpenL();
       
   146 	iUri = aUri;
       
   147 	}
       
   148 
       
   149 // -----------------------------------------------------------------------------
       
   150 // CMSRPFromPathHeader::ConstructL
       
   151 // -----------------------------------------------------------------------------
       
   152 //
       
   153 void CMSRPFromPathHeader::ConstructL( )
       
   154 	{
       
   155 	MSRPStrings::OpenL();
       
   156 	}
       
   157 
       
   158 // -----------------------------------------------------------------------------
       
   159 // CMSRPFromPathHeader::InternalizeValueL
       
   160 // -----------------------------------------------------------------------------
       
   161 //
       
   162 EXPORT_C CMSRPFromPathHeader* CMSRPFromPathHeader::InternalizeValueL(
       
   163 	RReadStream& aReadStream )
       
   164 	{
       
   165 	CMSRPFromPathHeader* self = CMSRPFromPathHeader::NewL( );
       
   166 	CleanupStack::PushL( self );
       
   167 	self->DoInternalizeValueL( aReadStream );
       
   168 	CleanupStack::Pop( self );
       
   169 	return self;
       
   170 	}
       
   171 
       
   172 // -----------------------------------------------------------------------------
       
   173 // CMSRPFromPathHeader::Name
       
   174 // -----------------------------------------------------------------------------
       
   175 //
       
   176 RStringF CMSRPFromPathHeader::Name() const
       
   177 	{
       
   178 	return MSRPStrings::StringF( MSRPStrConsts::EFromPath );
       
   179 	}
       
   180