1 // Copyright (c) 2008-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 "cstatetableparser.h"

    17 #include <upnpdescriptionschema.h>

    18 

    19 CStateTableParser* CStateTableParser::NewL(CUPnPStateVariable *aStateTable, const RStringPool& aStringPool)

    20 	{

    21 	CStateTableParser* self = new (ELeave) CStateTableParser(aStateTable, aStringPool);

    22 	return self;

    23 	}

    24 

    25 CStateTableParser::CStateTableParser(CUPnPStateVariable *aStateTable, const RStringPool& aStringPool) : iStateTable(aStateTable), iStringPool(aStringPool)

    26 	{

    27 	}

    28 

    29 CStateTableParser::~CStateTableParser()

    30 	{

    31 	}

    32 

    33 void CStateTableParser::ParseStartElementL(const RTagInfo& aElement, const RAttributeArray& aAttributes)

    34 	{

    35 	iSiblingsCount++;

    36 	iString = iStringPool.OpenStringL(aElement.LocalName().DesC());

    37 	TInt tblIndex = iString.Index ( UPNPDESCRIPTIONXMLTAGS::Table );

    38 	const TDesC8& str = iString.DesC();

    39 	switch(tblIndex)

    40 		{

    41 	case UPNPDESCRIPTIONXMLTAGS::EStateVariable:

    42 		{

    43 		_LIT8(KSendEvents,"sendEvents");

    44 		_LIT8(KYes,"yes");

    45 		_LIT8(KNo,"no");

    46 		

    47 		const RAttribute& attribute = aAttributes[0];

    48 		const RTagInfo& nameInfo = attribute.Attribute();

    49 

    50 		const TDesC8& localName = nameInfo.LocalName().DesC();

    51 		if ( localName.CompareF( KSendEvents ) )

    52 			User::Leave(KErrCorrupt);

    53 		const TDesC8& value = attribute.Value().DesC();

    54 		if ( !value.CompareF(KYes) )

    55 			iStateTable->SetPropertyL(iStringPool.String(UPNPDESCRIPTIONXMLTAGS::ESendEvents, UPNPDESCRIPTIONXMLTAGS::Table),KYes);

    56 			

    57 		else if ( !value.CompareF(KNo) )

    58 			iStateTable->SetPropertyL(iStringPool.String(UPNPDESCRIPTIONXMLTAGS::ESendEvents, UPNPDESCRIPTIONXMLTAGS::Table),KNo);

    59 		else

    60 			User::Leave(KErrCorrupt);

    61 		

    62 		}

    63 		

    64 	break;

    65 	

    66 	case UPNPDESCRIPTIONXMLTAGS::EAllowedValueList:

    67 		{

    68 		if ( !iArgValueList )

    69 			{

    70 			iArgValueList = CUPnPArgValueList::NewL();

    71 			iArgValueList->iType = CUPnPArgValueList::EArgValueList;

    72 			}

    73 		else

    74 			User::Leave(KErrCorrupt);

    75 		

    76 		iStateTable->SetAllowedValueType(ETrue);

    77 		iStateTable->SetAllowedValuesL(iArgValueList);

    78 		iFlags = iFlags | EAllowedValue;

    79 		}

    80 	break;

    81 		

    82 	case UPNPDESCRIPTIONXMLTAGS::EAllowedValueRange:

    83 		{

    84 		iSiblingsCount--;

    85 		CUPnPValueRange* valueRange = CUPnPValueRange::NewL();

    86 		valueRange->iType = CUPnPValueRange::EArgValueRange ;

    87 		CleanupStack::PushL(valueRange);

    88 		iStateTable->SetAllowedValuesL(valueRange);

    89 		iStateTable->SetAllowedValueType(EFalse);

    90 		CleanupStack::Pop();

    91 		CValueRangeParser* valueParser = CValueRangeParser::NewL(valueRange, iStringPool);

    92 		CleanupStack::PushL(valueParser);

    93 		StartChildParserL(valueParser, aElement, aAttributes);

    94 		CleanupStack::Pop(valueParser);

    95 		}

    96 	break;

    97 		//default : Don't do anything

    98 		}

    99 

   100 	}

   101 

   102 void CStateTableParser::ParseEndElementL(const RTagInfo& /*aElement*/)

   103 	{

   104 	iSiblingsCount--;

   105 	iStateTable->SetPropertyStatus(iString,ETrue);

   106 	iString.Close();

   107 	}

   108 	

   109 void CStateTableParser::ParseContentL(const TDesC8& aBytes)

   110 	{

   111 	if ( !IsBlankSpace( aBytes ) )

   112 		{

   113 		if ( iFlags == EAllowedValue )

   114 			iArgValueList->AppendL( aBytes );

   115 		else 

   116 			iStateTable->SetPropertyL(iString,aBytes);

   117 		}

   118 	}

   119 

   120 //------------------------------------------------------------------------------

   121 CValueRangeParser* CValueRangeParser::NewL(CUPnPValueRange* aValueRange, const RStringPool& aStringPool)

   122 	{

   123 	CValueRangeParser* self = new (ELeave) CValueRangeParser(aValueRange, aStringPool);

   124 	return self;

   125 	}

   126 

   127 CValueRangeParser::CValueRangeParser(CUPnPValueRange* aValueRange, const RStringPool& aStringPool) : iValueRange(aValueRange), iStringPool(aStringPool)

   128 	{

   129 	}

   130 

   131 CValueRangeParser::~CValueRangeParser()

   132 	{

   133 	}

   134 

   135 void CValueRangeParser::ParseStartElementL(const RTagInfo& aElement, const RAttributeArray& /*aAttributes*/)

   136 	{

   137 	iSiblingsCount++;

   138 	iString = iStringPool.OpenStringL(aElement.LocalName().DesC());

   139 	}

   140 

   141 void CValueRangeParser::ParseEndElementL(const RTagInfo& /*aElement*/)

   142 	{

   143 	iSiblingsCount--;

   144 	iValueRange->SetPropertyStatus(iString,ETrue);

   145 	iString.Close();

   146 	}

   147 

   148 void CValueRangeParser::ParseContentL(const TDesC8& aBytes)

   149 	{

   150 	if ( !IsBlankSpace( aBytes ) )

   151 		iValueRange->SetPropertyL( iString, aBytes );

   152 	

   153 	}

   154 

   155 

   156