// expect, but instead of returning the node,
// remove it
void opNode::Erase(Token t) {
opNode* errornode = this;
if (!IsEmpty() && GetPosition() != GetBegin()) {
iterator previous = GetPosition();
--previous;
errornode = *previous;
}
// check for end of block
if (GetPosition() == GetEnd()) {
opError::PrematureError(t, errornode, false);
}
Token tok = CurrentNode()->GetId();
// check for end of file
if (tok == T_EOF) {
opError::PrematureError(t, errornode, true);
}
// check for match
if (tok != t) opError::ExpectError(t, CurrentNode());
DeleteCurrentNode();
}
// ----------------------------------------------------------------------------
// TSdpAttributeParser::CheckValueL()
// Check the value of the current node is the same as the specified type.
// ----------------------------------------------------------------------------
//
void TSdpAttributeParser::CheckValueL( CSdpAttrValue& aValue ) const
{
switch ( aValue.Type() )
{
case ETypeNil:
Panic( ESdpAttributeParserNoValue );
break;
case ETypeUint:
if ( aValue.Uint() != ( TUint )CurrentNode().iValue )
{
User::Leave( KErrArgument );
}
break;
case ETypeInt:
if ( aValue.Int() != CurrentNode().iValue )
{
User::Leave( KErrArgument );
}
break;
case ETypeBoolean:
if ( aValue.Bool() != CurrentNode().iValue )
{
User::Leave( KErrArgument );
}
break;
case ETypeUUID:
if ( aValue.UUID() != TUUID( CurrentNode().iValue ) )
{
User::Leave( KErrArgument );
}
break;
// these are lists, so have to check contents
case ETypeDES:
case ETypeDEA:
Panic( ESdpAttributeParserValueIsList );
break;
// these aren't supported - use EReadValue and leave on error
//case ETypeString:
//case ETypeURL:
//case ETypeEncoded:
default:
Panic( ESdpAttributeParserValueTypeUnsupported );
break;
}
}
// ----------------------------------------------------------------------------
// TSdpAttributeParser::CheckTypeL()
// Check the type of the current node is the same as the specified type.
// ----------------------------------------------------------------------------
//
void TSdpAttributeParser::CheckTypeL( TSdpElementType aElementType ) const
{
if ( CurrentNode().iType != aElementType )
{
User::Leave( KErrGeneral );
}
}
// ----------------------------------------------------------------------------
// TSdpAttributeParser::EndListL()
// Process the end of a data element list.
// ----------------------------------------------------------------------------
//
void TSdpAttributeParser::EndListL()
{
// check we are at the end of a list
if ( CurrentNode().iCommand != ECheckEnd )
{
User::Leave( KErrGeneral );
}
AdvanceL();
}
// ----------------------------------------------------------------------------
// TSdpAttributeParser::AdvanceL()
// Advance to the next node.
// ----------------------------------------------------------------------------
//
void TSdpAttributeParser::AdvanceL()
{
// check not at end
if ( CurrentNode().iCommand == EFinished )
{
User::Leave( KErrEof );
}
// move to the next item
++iCurrentNodeIndex;
}
void ParseString(const FString& StringToParse)
{
DataIndex = 0;
DataString = StringToParse;
if (DataIndex >= DataString.Len())
{
return;
}
const FString TabString(TEXT(" "));
FColor TagColor;
FNode CurrentNode(DefaultColor);
for (EStringParserToken Token = ReadToken(); Token != EStringParserToken::EndOfString; Token = ReadToken())
{
switch (Token)
{
case EStringParserToken::RegularChar:
CurrentNode.String.AppendChar(DataString[DataIndex]);
break;
case EStringParserToken::NewLine:
NodeList.Add(CurrentNode);
CurrentNode = FNode(NodeList.Last().Color);
CurrentNode.bNewLine = true;
break;
case EStringParserToken::Tab:
CurrentNode.String.Append(TabString);
break;
case EStringParserToken::OpenTag:
if (ParseTag(TagColor))
{
NodeList.Add(CurrentNode);
CurrentNode = FNode(TagColor);
}
break;
}
DataIndex++;
}
NodeList.Add(CurrentNode);
}
// ----------------------------------------------------------------------------
// TSdpAttributeParser::VisitAttributeValueL()
// Process a data element.
// ----------------------------------------------------------------------------
//
void TSdpAttributeParser::VisitAttributeValueL( CSdpAttrValue& aValue,
TSdpElementType aType )
{
switch ( CurrentNode().iCommand )
{
case ECheckType:
CheckTypeL( aType );
break;
case ECheckValue:
CheckTypeL( aType );
CheckValueL( aValue );
break;
case ECheckEnd:
User::Leave( KErrGeneral ); //list element contains too many items
break;
case ESkip:
break; // no checking required
case EReadValue:
CheckTypeL( aType );
ReadValueL( aValue );
break;
case EFinished:
User::Leave( KErrGeneral ); // element is after
return; // value should have ended
default:
Panic( ESdpAttributeParserInvalidCommand );
}
AdvanceL();
}
// ----------------------------------------------------------------------------
// TSdpAttributeParser::HasFinished()
// Check if parsing processed the whole list.
// ----------------------------------------------------------------------------
//
TBool TSdpAttributeParser::HasFinished() const
{
return CurrentNode().iCommand == EFinished;
}
// ----------------------------------------------------------------------------
// TSdpAttributeParser::ReadValueL()
// Pass the data element value to the observer.
// ----------------------------------------------------------------------------
//
void TSdpAttributeParser::ReadValueL( CSdpAttrValue& aValue ) const
{
iObserver.FoundElementL( CurrentNode().iValue, aValue );
}
