1 // Copyright (c) 2001-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15  

    16 #include "VTicketMaster.H"

    17 

    18 #include <s32mem.h>

    19 #include <e32std.h>

    20 

    21 #include <vutil.h>

    22 #include <vstaticutils.h>

    23 

    24 

    25 EXPORT_C CParserVTicketmaster* CParserVTicketmaster::NewL()

    26 	{

    27 	CParserVTicketmaster* self=new(ELeave) CParserVTicketmaster();

    28 	CleanupStack::PushL(self);

    29 	self->ConstructL();

    30 	CleanupStack::Pop(self);

    31 	return self;	

    32 	}

    33 

    34 CParserVTicketmaster::CParserVTicketmaster()

    35 : CVersitParser(ESupportsVersion)

    36 	{

    37 	iDefaultVersion = KVersitTokenVTicketmasterVersionNo;

    38 	}

    39 

    40 EXPORT_C void CParserVTicketmaster::ExternalizeL(RWriteStream& aStream)

    41 	{

    42 	if	(!iEntityName)

    43 		SetEntityNameL(KVersitVarTokenVCONCERT);

    44 	CVersitParser::ExternalizeL(aStream);

    45 	}

    46 

    47 EXPORT_C TUid CParserVTicketmaster::RecognizeToken(const TDesC8& aToken) const

    48 // From CVersitParser

    49 	{

    50 	TUid uid = KNullUid;

    51 	TChar firstChar(aToken.Ptr()[0]);

    52 	firstChar=firstChar.GetUpperCase();

    53 	switch (firstChar)

    54 		{

    55 	case 'V':

    56 		if (!aToken.CompareF(KVersitTokenVERSION))

    57 			uid.iUid = KVersitPropertyHBufCUid;

    58 		break;

    59 	default:

    60 		break;

    61 		}

    62 	if (uid == KNullUid)

    63 		return CVersitParser::RecognizeToken(aToken);		

    64 	return uid;

    65 	}

    66 

    67 EXPORT_C TUid CParserVTicketmasterEntity::RecognizeToken(const TDesC8& aToken) const

    68 // From CVersitParser

    69 	{

    70 	TUid uid = KNullUid;

    71 	TChar firstChar(aToken.Ptr()[0]);

    72 	firstChar=firstChar.GetUpperCase();

    73 	switch (firstChar)

    74 		{

    75 	case 'A':

    76 		if (!aToken.CompareF(KVersitTokenARTIST))

    77 			uid.iUid = KVersitPropertyHBufCUid;

    78 		break;

    79 	case 'B':

    80 		if (!aToken.CompareF(KVersitTokenBOOKINGFEE))

    81 			uid.iUid = KVTicketmasterPriceUid;

    82 		break;

    83 	case 'C':

    84 		if (!aToken.CompareF(KVersitTokenCONCERTDATE))

    85 			uid.iUid = KVersitPropertyDateTimeUid;

    86 		break;

    87 	case 'E':

    88 		if (!aToken.CompareF(KVersitTokenEVENTCODE))

    89 			uid.iUid = KVTicketmasterEventCodeUid;

    90 		break;

    91 	case 'N':

    92 		if (!aToken.CompareF(KVersitTokenNUMBEROFTICKETS))

    93 			uid.iUid = KVersitPropertyIntUid;

    94 		break;

    95 	case 'O':

    96 		if (!aToken.CompareF(KVersitTokenORGANISATION))

    97 			uid.iUid = KVersitPropertyHBufCUid;

    98 		else if (!aToken.CompareF(KVersitTokenOTHERRELATEDSHOWS))

    99 			uid.iUid = KVTicketmasterOtherRelatedShowsId;

   100 		break;

   101 	case 'P':

   102 		if (!aToken.CompareF(KVersitTokenPRICELEVEL))

   103 			uid.iUid = KVersitPropertyIntUid;

   104 		break;

   105 	case 'S':

   106 		if (!aToken.CompareF(KVersitTokenSEATNUMBERS))

   107 			uid.iUid = KVTicketmasterSeatNumUid;

   108 		else if (!aToken.CompareF(KVersitTokenSUPPORTINGACT))

   109 			uid.iUid = KVersitPropertyHBufCUid;

   110 		break;

   111 	case 'T':

   112 		if (!aToken.CompareF(KVersitTICKETTERMINAL))

   113 			uid.iUid = KVersitPropertyIntUid;

   114 		else if (!aToken.CompareF(KVersitTokenTICKETPRICE))

   115 			uid.iUid = KVTicketmasterPriceUid;

   116 		break;

   117 	case 'V':

   118 		if (!aToken.CompareF(KVersitTokenVENUE))

   119 			uid.iUid = KVersitPropertyHBufCUid;

   120 		break;

   121 	default:

   122 		break;

   123 		}

   124 	if (uid == KNullUid)

   125 		return CVersitParser::RecognizeToken(aToken);		

   126 	return uid;

   127 	}

   128 

   129 EXPORT_C TInt CParserVTicketmaster::RecognizeEntityName() const

   130 // From CVersitParser

   131 	{

   132 	if (iCurrentProperty && iCurrentProperty->Value())

   133 		{

   134 		TPtrC entityName=STATIC_CAST(CParserPropertyValueHBufC*,iCurrentProperty->Value())->Value();

   135 		if (entityName==KVersitVarTokenVCONCERT)

   136 			return KVTicketmasterEntityUidVConcert;

   137 		else if (entityName==KVersitVarTokenVMUSICAL)

   138 			return KVTicketmasterEntityUidVMusical;

   139 		}

   140 	return 0;

   141 	}

   142 

   143 EXPORT_C CVersitParser* CParserVTicketmaster::MakeEntityL(TInt aEntityUid,HBufC* aEntityName)

   144 // From CVersitParser

   145 	{

   146 	CVersitParser* newEntity = NULL;

   147 	CleanupStack::PushL(aEntityName);

   148 	switch (aEntityUid)

   149 		{

   150 		case KVTicketmasterEntityUidVConcert:

   151 		case KVTicketmasterEntityUidVMusical:

   152 			newEntity=CParserVTicketmasterEntity::NewL();

   153 			break;

   154 		default: 

   155 			//if entity is not concert nor musical,

   156 			//then create base class entity with no version

   157 			newEntity = new(ELeave) CVersitParser(ENoVersionProperty);

   158 			CleanupStack::PushL(newEntity);

   159 			newEntity->ConstructL();

   160 			CleanupStack::Pop(newEntity);

   161 		}

   162 	CleanupStack::Pop(aEntityName);

   163 	CleanupStack::PushL(newEntity);		//Cannot leave as we have just popped an item and the stack never shrinks

   164 	newEntity->InternalizeL(aEntityName, iLineReader);

   165 	CleanupStack::Pop(newEntity);

   166 	return newEntity;

   167 	}

   168 

   169 CParserPropertyValue* CParserVTicketmasterEntity::MakePropertyValueL(const TUid& aPropertyUid,HBufC16*& aValue)

   170 // From CVersitParser

   171 	{

   172 	switch (aPropertyUid.iUid)

   173 		{

   174 		case KVTicketmasterPriceUid: //won't be recognized except by subclass

   175 			return MakePropertyValuePriceL(aValue->Des());

   176 		case KVTicketmasterEventCodeUid:

   177 			return MakePropertyValueEventCodeL(aValue->Des());

   178 		case KVTicketmasterSeatNumUid:

   179 			return MakePropertyValueSeatNumL(aValue->Des());

   180 		case KVTicketmasterOtherRelatedShowsId:

   181 			{

   182 			CParserPropertyValue* value = NULL;

   183 			CPtrCArray* array=MakePropertyValueOtherRelatedShowsL(aValue->Des());

   184 			CleanupStack::PushL(array);

   185 			value = new(ELeave) CParserPropertyValueOtherRelatedShows(array);

   186 			aValue = NULL;

   187 			CleanupStack::Pop(array);

   188 			return value;

   189 			}

   190 			

   191 		default:

   192 			break;

   193 		};

   194 	return CVersitParser::MakePropertyValueL(aPropertyUid,aValue);

   195 	}

   196 

   197 EXPORT_C CParserPropertyValue* CParserVTicketmasterEntity::MakePropertyValuePriceL(TPtr16 aPriceValue)

   198 	{

   199 	const TInt stringLength = aPriceValue.Length();

   200 	TInt valueInPennys = 0;

   201 	TInt valueInPounds = 0;

   202 	TChar currencySymbol = 0xa4; //£ symbol

   203 

   204 	TInt i=0;

   205 	//check if there is any white space before hitting £ symbol

   206 	//we have assume the case that all price values are non-corrupted

   207 	while (VersitUtils::IsWhiteSpace(aPriceValue[i]) && i<stringLength)

   208 		++i;

   209 

   210 	if (i==stringLength) //when there is nothing after £ symbol

   211 		{

   212 		CParserPropertyValue* value = new(ELeave) CParserPropertyValuePrice(currencySymbol, '.', valueInPounds, valueInPennys);

   213 		return value;

   214 		}

   215 

   216 	const TInt currencySymbolPosition = i; //remembering where £ symbol is

   217 

   218 	TInt actualValue = aPriceValue[++i];

   219 

   220 	//work out the pounds part of the value

   221 	while ((VersitUtils::IsWhiteSpace(actualValue) || (actualValue>='0' && actualValue<='9')) && i<stringLength) 

   222 		{

   223 		if (actualValue>='0' && actualValue<='9')

   224 			valueInPounds = 10*valueInPounds + actualValue -'0';

   225 		if ((++i)<stringLength) //this condition will kept in used when there is no penny or decimal point of the price value

   226 			actualValue = aPriceValue[i];

   227 		}

   228 	CParserPropertyValue* value = NULL;

   229 

   230 	if (i==stringLength) //when there are no pennys & no decimal point

   231 		value = new(ELeave) CParserPropertyValuePrice(aPriceValue[currencySymbolPosition], '.', valueInPounds, valueInPennys);

   232 	else if (i<stringLength) //when there is a decimal point

   233 		{

   234 		const TInt decimalPos = i;

   235 		actualValue = aPriceValue[++i];

   236 

   237 		//work out the pennys part of the value

   238 		while (i<stringLength) 

   239 			{

   240 			if (actualValue>='0' && actualValue<='9')

   241 				valueInPennys = 10*valueInPennys + actualValue -'0';

   242 			if ((++i)<stringLength)

   243 				actualValue = aPriceValue[i];

   244 			}

   245 		value = new(ELeave) CParserPropertyValuePrice(aPriceValue[currencySymbolPosition], aPriceValue[decimalPos], valueInPounds, valueInPennys);

   246 		}

   247 	return value;

   248 	}

   249 

   250 EXPORT_C CParserPropertyValue* CParserVTicketmasterEntity::MakePropertyValueEventCodeL(TPtr16 aEventCodeValue)

   251 	{

   252 	TInt i = 0;

   253 	//assuming no white space before the number begins

   254 	while (aEventCodeValue[i] != KHyphen)

   255 		++i;

   256 

   257 	TInt firstCode = 0;

   258 	TInt firstCodeLength = i;

   259 	TPtr16 num(&aEventCodeValue[0], firstCodeLength, firstCodeLength);

   260 	Val(num, firstCode);

   261 

   262 	TInt positionOfSecondCode = ++i;

   263 	while (aEventCodeValue[i] != KHyphen)

   264 		++i;

   265 	

   266 	TInt secondCodeLength = i - positionOfSecondCode;

   267 	TInt secondCode = 0;

   268 	num.Set(&aEventCodeValue[positionOfSecondCode], secondCodeLength, secondCodeLength);

   269 	Val(num, secondCode);

   270 

   271 	++i;

   272 	TInt thirdCodeLength = aEventCodeValue.Length() - i;

   273 	TInt thirdCode = 0;

   274 	num.Set(&aEventCodeValue[i], thirdCodeLength, thirdCodeLength);

   275 	Val(num, thirdCode);

   276 	

   277 	CParserPropertyValue* value = new(ELeave) CParserPropertyValueEventCode(firstCode, firstCodeLength,

   278 																			secondCode, secondCodeLength,

   279 																			thirdCode, thirdCodeLength);

   280 	return value;

   281 	}

   282 

   283 //

   284 // Data type that will pass into this function looks like

   285 // A7,BA4,AG8,B4

   286 //

   287 CParserPropertyValue* CParserVTicketmasterEntity::MakePropertyValueSeatNumL(TPtr16 aSeatNum)

   288 	{

   289 	TInt i = 0;

   290 	TInt stringLength = aSeatNum.Length();

   291 	TInt seatLength = 0; //the length of the seat, e.g seat A1->seatLength=2, seat AB1->seatLength=3

   292 	TSeatNum seat;

   293 	RArray<TSeatNum> seatArray;

   294 	TPtr16 specificSeat(&aSeatNum[0], seatLength, seatLength); //initialization of specificSeat

   295 

   296 	while (i<stringLength) //scan through the string until reaching the last one

   297 		{

   298 		TInt firstCharacterOfSeat = i-seatLength; //position of the first character

   299 		

   300 		if (aSeatNum[i] == KComma)

   301 			{

   302 			specificSeat.Set(&aSeatNum[firstCharacterOfSeat], seatLength, seatLength);

   303 			CreateSeatsL(seat, specificSeat);

   304 

   305 			seatLength = 0;

   306 

   307 			seatArray.InsertInOrder(seat,TLinearOrder<TSeatNum>(TSeatNum::CompareSeats));;

   308 			}

   309 		else if (aSeatNum[i] == KHyphen) //if it is A1-7,A9 OR just A1-7

   310 			{

   311 			specificSeat.Set(&aSeatNum[firstCharacterOfSeat], seatLength, seatLength);

   312 			CreateSeatsL(seat, specificSeat);

   313 

   314 			seatLength = 0;

   315 

   316 			++i;

   317 			while (i+1<=stringLength && aSeatNum[i]!=KComma)

   318 				{

   319 				++seatLength;

   320 				++i;

   321 				}

   322 

   323 			TInt temp;

   324 			TPtr16 num(&aSeatNum[i-seatLength], seatLength, seatLength);

   325 			Val(num, temp);

   326 			seat.iNextSeats = temp - seat.iSeatNum;

   327 

   328 			seatArray.InsertInOrder(seat,TLinearOrder<TSeatNum>(TSeatNum::CompareSeats));

   329 

   330 			seatLength = 0;

   331 

   332 			}

   333 		else if (i+1>=stringLength) //if it is the last one in the string

   334 			{

   335 			specificSeat.Set(&aSeatNum[firstCharacterOfSeat], seatLength+1, seatLength+1);

   336 			CreateSeatsL(seat, specificSeat);

   337 

   338 			seatArray.InsertInOrder(seat,TLinearOrder<TSeatNum>(TSeatNum::CompareSeats));;

   339 			}

   340 		else

   341 			++seatLength;

   342 

   343 		++i;

   344 		}

   345 

   346 	//buf is for testing purpose - to check what is stored in the array

   347 	TBuf8<200> buf;

   348 	TInt arrayLength = seatArray.Count();

   349 	for (TInt j=0; j<arrayLength; j++)

   350 		{

   351 		buf.Append(seatArray[j].iRow);

   352 		buf.Append(seatArray[j].iSeatNum);

   353 		buf.Append(seatArray[j].iNextSeats);

   354 		}

   355 

   356 	TInt m=0;

   357 	//detecting those that should be in the same range

   358 	while (m+1<seatArray.Count())

   359 		{

   360 		if (seatArray[m].iRow == seatArray[m+1].iRow)

   361 			{

   362 			if (seatArray[m+1].iSeatNum - seatArray[m].iSeatNum - seatArray[m].iNextSeats== 1)

   363 				{

   364 				seatArray[m].iNextSeats = seatArray[m].iNextSeats + seatArray[m+1].iNextSeats + 1;

   365 				seatArray.Remove(m+1);

   366 				}

   367 			else if(seatArray[m+1].iSeatNum - seatArray[m].iSeatNum - seatArray[m].iNextSeats < 1)

   368 				{

   369 				seatArray.Remove(m+1);

   370 				}

   371 			else

   372 				m++;

   373 			}

   374 		else

   375 			m++;

   376 		}

   377 

   378 	//The buf is for testing purpose, to see what is stored after sorting

   379 	for (TInt k=0; k<seatArray.Count(); k++)

   380 		{

   381 		buf.Append(seatArray[k].iRow);

   382 		buf.Append(seatArray[k].iSeatNum);

   383 		buf.Append(seatArray[k].iNextSeats);

   384 		}

   385 

   386 	CParserPropertyValue* value = new(ELeave) CParserPropertyValueSeatNum(seatArray);

   387 	return value;

   388 	}

   389 

   390 

   391 void CParserVTicketmasterEntity::CreateSeatsL(TSeatNum& aSeat, 

   392 											 TPtr16& aSpecificSeat)

   393 	{

   394 	TInt i=0;

   395 	TInt stringLength = aSpecificSeat.Length();

   396 

   397 	while (!(aSpecificSeat[i]>='0' && aSpecificSeat[i]<='9'))

   398 		++i;

   399 

   400 	__ASSERT_ALWAYS(i<=2, User::Leave(KErrGeneral));

   401 

   402 	TPtr16 num(&aSpecificSeat[0], i, i);

   403 	aSeat.iRow = num;

   404 

   405 	num.Set(&aSpecificSeat[i], stringLength-i, stringLength-i);

   406 	Val(num, aSeat.iSeatNum);

   407 

   408 	aSeat.iNextSeats = 0;

   409 

   410 	}

   411 

   412 

   413 TInt TSeatNum::CompareSeats(const TSeatNum& aFirst, const TSeatNum& aSecond)

   414 	{

   415 	if (aFirst.iRow.Length() == aSecond.iRow.Length())

   416 		{

   417 		if (aFirst.iRow.Length() == 1)

   418 			{

   419 			if (aFirst.iRow == aSecond.iRow)

   420 				return (aFirst.iSeatNum - aSecond.iSeatNum);

   421 			else 

   422 				return (aFirst.iRow[0] - aSecond.iRow[0]);

   423 			}

   424 		else

   425 			{

   426 			if (aFirst.iRow[0] == aSecond.iRow[0])

   427 				{

   428 				if (aFirst.iRow[1]==aSecond.iRow[1])

   429 					return (aFirst.iSeatNum - aSecond.iSeatNum);

   430 				else

   431 					return (aFirst.iRow[1] - aSecond.iRow[1]);

   432 				}

   433 			else

   434 				return (aFirst.iRow[0] - aSecond.iRow[0]);

   435 			}

   436 		}

   437 	else

   438 		return (aFirst.iRow.Length() - aSecond.iRow.Length());

   439 	}

   440 

   441 

   442 

   443 //

   444 // input data may look like STEPS;KYLIE;SAM

   445 //

   446 CPtrCArray* CParserVTicketmasterEntity::MakePropertyValueOtherRelatedShowsL(TPtr16 aShow)

   447 	{

   448 	TInt stringLength = aShow.Length();

   449 	CPtrCArray* arrayOfValues = new(ELeave)CPtrC16Array(5);

   450 

   451 	TInt i = 0;

   452 	TInt showLength = 0; //length of the string of the show, say STEPS->showLength=5

   453 	while(i<stringLength)

   454 		{

   455 		if (aShow[i] == KSemiColon)

   456 			{

   457 			TPtr16 show(&aShow[i-showLength], showLength, showLength);

   458 			arrayOfValues->AppendL(show);

   459 			showLength = 0;

   460 			}

   461 		else if (i+1>=stringLength)

   462 			{

   463 			TPtr16 show(&aShow[i-showLength], showLength+1, showLength+1);

   464 			arrayOfValues->AppendL(show);

   465 			}

   466 		else

   467 			++showLength;

   468 		++i;

   469 		}

   470 

   471 	return arrayOfValues;

   472 	}

   473 

   474 //*************************************************************************************

   475 //

   476 // CParserPropertyValuePrice

   477 //

   478 //*************************************************************************************

   479 EXPORT_C CParserPropertyValuePrice::CParserPropertyValuePrice(TChar aCurrencySymbol, TChar aDecimalPoint, TInt aPounds, TInt aPennys)

   480 :CParserPropertyValue(TUid::Uid(KVTicketmasterPriceUid))

   481 ,iCurrencySymbol(aCurrencySymbol)

   482 ,iDecimalPoint(aDecimalPoint)

   483 ,iPounds(aPounds)

   484 ,iPennys(aPennys)

   485 	{}

   486 

   487 EXPORT_C CParserPropertyValuePrice::~CParserPropertyValuePrice()

   488 	{

   489 	}

   490 

   491 EXPORT_C void CParserPropertyValuePrice::ExternalizeL(RWriteStream& aStream, const Versit::TEncodingAndCharset& /*aEncodingCharset*/

   492 													  ,TInt /*aLengthOutput*/)

   493 	{

   494 	TBuf8<KVersitDefaultBufferSize> buf;

   495 	buf.Append(iCurrencySymbol);

   496 	buf.AppendNum(iPounds);

   497 	buf.Append(iDecimalPoint);

   498 	buf.AppendNumFixedWidth(iPennys, EDecimal, 2);

   499 	aStream.WriteL(buf);

   500 	}

   501 

   502 

   503 //*************************************************************************************

   504 //

   505 // CParserPropertyValueEventCode

   506 //

   507 //*************************************************************************************

   508 

   509 CParserPropertyValueEventCode::CParserPropertyValueEventCode(TInt aFirstCode, TInt aFirstCodeLength,

   510 															 TInt aSecondCode, TInt aSecondCodeLength,

   511 															 TInt aThirdCode, TInt aThirdCodeLength)

   512 :CParserPropertyValue(TUid::Uid(KVTicketmasterEventCodeUid))

   513 ,iFirstCode(aFirstCode)

   514 ,iSecondCode(aSecondCode)

   515 ,iThirdCode(aThirdCode)

   516 ,iFirstCodeLength(aFirstCodeLength)

   517 ,iSecondCodeLength(aSecondCodeLength)

   518 ,iThirdCodeLength(aThirdCodeLength)

   519 	{}

   520 

   521 

   522 void CParserPropertyValueEventCode::ExternalizeL(RWriteStream& aStream, const Versit::TEncodingAndCharset& aEncodingCharset

   523 													  ,TInt /*aLengthOutput*/)

   524 	{

   525 

   526 	__ASSERT_ALWAYS(aEncodingCharset.iEncoding!=Versit::EBase64Encoding, TMPanic(EUnexpectedBase64));

   527 

   528 	TBuf8<KVersitDefaultBufferSize> buf;

   529 	buf.AppendNumFixedWidth(iFirstCode, EDecimal, iFirstCodeLength);

   530 	buf.Append('-');

   531 	buf.AppendNumFixedWidth(iSecondCode, EDecimal, iSecondCodeLength);

   532 	buf.Append('-');

   533 	buf.AppendNumFixedWidth(iThirdCode, EDecimal, iThirdCodeLength);

   534 	aStream.WriteL(buf);

   535 	}

   536 

   537 

   538 

   539 //*************************************************************************************

   540 //

   541 // CParserPropertyValueSeatNumL

   542 //

   543 //*************************************************************************************

   544 CParserPropertyValueSeatNum::CParserPropertyValueSeatNum(RArray<TSeatNum>& aSeatArray)

   545 :CParserPropertyValue(TUid::Uid(KVTicketmasterSeatNumUid))

   546 ,iSeatArray(aSeatArray)

   547 	{}

   548 

   549 CParserPropertyValueSeatNum::~CParserPropertyValueSeatNum()

   550 	{

   551 	}

   552 

   553 void CParserPropertyValueSeatNum::ExternalizeL(RWriteStream& aStream, const Versit::TEncodingAndCharset& /*aEncodingCharset*/

   554 													  ,TInt /*aLengthOutput*/)

   555 	{

   556 	TBuf8<KVersitDefaultBufferSize> buf;

   557 

   558 	iArrayLength = iSeatArray.Count();

   559 	for (TInt i=0; i<iArrayLength; i++)

   560 		{

   561 		if (iSeatArray[i].iNextSeats > 0)

   562 			{

   563 			buf.Append(iSeatArray[i].iRow);

   564 			buf.AppendNum(iSeatArray[i].iSeatNum);

   565 			buf.Append('-');

   566 			buf.AppendNum(iSeatArray[i].iNextSeats + iSeatArray[i].iSeatNum);

   567 			}

   568 		else

   569 			{

   570 			buf.Append(iSeatArray[i].iRow);

   571 			buf.AppendNum(iSeatArray[i].iSeatNum);

   572 			}

   573 

   574 		if (i+1<iArrayLength)

   575 			buf.Append(KComma);

   576 

   577 		aStream.WriteL(buf);

   578 		buf.Zero();

   579 			

   580 		}

   581 	}

   582 

   583 

   584 

   585 //*************************************************************************************

   586 //

   587 // CParserPropertyValueOtherRelatedShows

   588 //

   589 //*************************************************************************************

   590 

   591 CParserPropertyValueOtherRelatedShows::CParserPropertyValueOtherRelatedShows(CPtrCArray* aShowArray)

   592 :CParserPropertyValue(TUid::Uid(KVTicketmasterOtherRelatedShowsId))

   593 ,iShowArray(aShowArray)

   594 	{}

   595 

   596 CParserPropertyValueOtherRelatedShows::~CParserPropertyValueOtherRelatedShows()

   597 	{

   598 	delete iShowArray;

   599 	}

   600 

   601 void CParserPropertyValueOtherRelatedShows::ExternalizeL(RWriteStream& aStream, const Versit::TEncodingAndCharset& /*aEncodingCharset*/

   602 													  ,TInt /*aLengthOutput*/)

   603 	{

   604 	TBuf8<KVersitDefaultBufferSize> buf;

   605 	TInt arraySize = iShowArray->Count();

   606 	for (TInt j=0; j<arraySize; j++)

   607 		{

   608 		buf.Append(iShowArray->At(j));

   609 

   610 		if (j+1<arraySize)

   611 		buf.Append(KSemiColon);

   612 

   613 		aStream.WriteL(buf);

   614 		buf.Zero();

   615 		}

   616 	}

   617 

   618 

   619 //*************************************************************************************

   620 //

   621 //CParserTicketmasterEntity

   622 //

   623 //*************************************************************************************

   624 

   625 EXPORT_C CParserVTicketmasterEntity* CParserVTicketmasterEntity::NewL()

   626 	{

   627 	CParserVTicketmasterEntity* self=new(ELeave) CParserVTicketmasterEntity();

   628 	CleanupStack::PushL(self);

   629 	self->ConstructL();

   630 	CleanupStack::Pop(self);

   631 	return self;	

   632 	}

   633 

   634 // Constructs a vTicketmaster sub-entity parser.

   635 CParserVTicketmasterEntity::CParserVTicketmasterEntity()

   636 : CVersitParser(EFalse)

   637 	{

   638 	}

   639 

   640 //The destructor is empty, and is present only to cause the virtual

   641 //function table to be defined in a unique module.

   642 CParserVTicketmasterEntity::~CParserVTicketmasterEntity()

   643 	{

   644 	}

   645 

   646