/*

* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Parse WebDAV LOCK method response body

 *

*/

// INCLUDE FILES

#include "rsfwlockqueryparser.h"

#include "rsfwdavfileinfo.h"

#include "mdebug.h"

// CONSTANTS

_LIT(KTimeOutTag,"Second-");

// ============================ MEMBER FUNCTIONS ==============================

CRsfwLockQueryParser* CRsfwLockQueryParser::NewLC()

    {

    CRsfwLockQueryParser* self = new(ELeave) CRsfwLockQueryParser;

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CRsfwLockQueryParser* CRsfwLockQueryParser::NewL()

    {

    CRsfwLockQueryParser* self = NewLC();

    CleanupStack::Pop(self);

    return self;

    }

void CRsfwLockQueryParser::ConstructL()

    {

    /*

      iParseState = ELooking;

    */

    }

CRsfwLockQueryParser::~CRsfwLockQueryParser()

    {

    delete iContentString;

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::OnStartDocumentL

// This method is a callback to indicate the start of the document.

// @param aDocParam Specifies the various parameters of the document.

// @arg aDocParam.iCharacterSetName The character encoding of the document.

// ----------------------------------------------------------------------------

//

void CRsfwLockQueryParser::OnStartDocumentL(

    const Xml::RDocumentParameters& /* aDocParam */,

    TInt /* aErrCode */)

    {

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::OnStartDocumentL

// This method is a callback to indicate the end of the document.

// ----------------------------------------------------------------------------

//

void CRsfwLockQueryParser::OnEndDocumentL(TInt aErrCode)

    {

    if (aErrCode)

        {

        User::Leave(aErrCode);

        }

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::OnStartElementL

// This method is a callback to indicate an element has been parsed.

// @param aElement is a handle to the element's details.

// @param aAttributes contains the attributes for the element.

// @param aErrorCode is the error code.

// If this is not KErrNone then special action may be required.

// ----------------------------------------------------------------------------

//

void CRsfwLockQueryParser::OnStartElementL(

    const Xml::RTagInfo& aElement,

    const Xml::RAttributeArray& /* aAttributes */,

    TInt aErrorCode)

    {

    _LIT8(KLockType, "locktype");

    _LIT8(KLockScope, "lockscope");

    _LIT8(KDepth, "depth");

    _LIT8(KTimeout, "timeout");

    _LIT8(KLockToken, "locktoken");

    if (aErrorCode)

        {

        User::Leave(aErrorCode);

        }

    switch (iParseState)

        {

    case ELockType:

        // Currently, write is the only acquired type, might change later

        break;

    case ELockScope:

        // Currently, exclusive is the only acquired type, might change later

        break;

    case EDepth:

        break;

    case ETimeout:

        break;

    case ELockToken:

        {

        _LIT8(KHref, "href");

        if (((aElement.LocalName()).DesC()).Compare(KHref) == 0)

            {

            iParseState = EHrefToken;

            }

        }

        break;

    case EHrefToken:

        break;

    case ELooking: // we are trying to find the next interesting tag

        if (((aElement.LocalName()).DesC()).Compare(KLockType) == 0)

            {

            iParseState = ELockType;

            }

        else if (((aElement.LocalName()).DesC()).Compare(KLockScope) == 0)

            {

            iParseState = ELockScope;

            }

        else if (((aElement.LocalName()).DesC()).Compare(KDepth) == 0)

            {

            iParseState = EDepth;

            }

        else if (((aElement.LocalName()).DesC()).Compare(KTimeout) == 0)

            {

            iParseState = ETimeout;

            }

        else if (((aElement.LocalName()).DesC()).Compare(KLockToken) == 0)

            {

            iParseState = ELockToken;

            }

        else

            {

            // lint

            }

        break;

    default:

        break;

        }

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::OnEndElementL

// This method is a callback to indicate that end of element has been reached.

// @param aElement is a handle to the element's details.

// @param aErrorCode is the error code.

// If this is not KErrNone then special action may be required.

// ----------------------------------------------------------------------------

//

void CRsfwLockQueryParser::OnEndElementL(const Xml::RTagInfo& /* aElement */,

                                     TInt aErrorCode)

    {

    if (aErrorCode)

        {

        User::Leave(aErrorCode);

        }

    // otherwise we will continue reading

    // if we have some interesting content

    if ((iParseState != ELooking) && !iContentString)

        {

        iParseState = ELooking;

        return;

        }

    switch (iParseState)

        {

    case ELockType:

        break;

    case ELockScope:

        break;

    case EDepth:

        {

        /*

          TPtrC aux;

          aux.Set(aBuf);

          TLex lex(aux);

          lex.Val(iDepth);

        */

        }

        break;

    case ETimeout:

        {

        if (iDavFileInfo)

            {

            _LIT8(KInfinite, "Infinite");

            if (iContentString->Compare(KInfinite) == 0)

                {

                iDavFileInfo->SetTimeout(KMaxTUint);

                }

            else

                {

                // We expect 'Second-x" where x a positive integer

                TInt timeout = 0;

                if (iContentString->Length() > KTimeOutTag().Length())

                    {

                    TPtrC8 aux;

                    aux.Set(*iContentString);

                    TLex8 lex(aux);

                    lex.SkipAndMark(KTimeOutTag().Length());

                    lex.Val(timeout);

                    }

                iDavFileInfo->SetTimeout(timeout);

                }

            }

        }

        break;

    case ELockToken:

        break;

    case EHrefToken:

        if (iDavFileInfo)

            {

            iDavFileInfo->SetLockTokenL(*iContentString);

            }

        break;

    case ELooking:

        break;

    default:

        break;

        }

    delete iContentString;

    iContentString = NULL;

    iParseState = ELooking;

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::OnContentL

// This method is a callback that sends the content of the element.

// Not all the content may be returned in one go.

// The data may be sent in chunks.

// When an OnEndElementL is received there is no more content to be sent.

// @param aBytes is the raw content data for the element.

// The client is responsible for converting the data to the

// required character set if necessary.

// In some instances the content may be binary and must not be converted.

// @param aErrorCode is the error code.

// If this is not KErrNone then special action may be required.

//

void CRsfwLockQueryParser::OnContentL(const TDesC8& aBytes, TInt aErrorCode)

    {

    if (aErrorCode)

        {

        User::Leave(aErrorCode);

        }

    // We want to add to contentstring only if we are in a state

    // where the content is interesting to us

    if ((iParseState == ETimeout) || (iParseState == EHrefToken))

        {

        if (!iContentString)

            {

            iContentString = HBufC8::NewL(aBytes.Length());

            TPtr8 string = iContentString->Des();

            string.Append(aBytes);

            }

        else

            {

            iContentString =

                iContentString->ReAllocL(iContentString->Length() +

                                         aBytes.Length());

            TPtr8 string = iContentString->Des();

            string.Append(aBytes);

            }

        }

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::OnStartPrefixMappingL

// This method is a notification of the beginning of the scope of a prefix-URI

// Namespace mapping.

// This method is always called before corresponding OnStartElementL method.

// @param aPrefix is the Namespace prefix being declared.

// @param aUri is the Namespace URI the prefix is mapped to.

// @param aErrorCode is the error code.

// If this is not KErrNone then special action may be required.

// ----------------------------------------------------------------------------

//

void CRsfwLockQueryParser::OnStartPrefixMappingL(const RString& /* aPrefix */,

                                             const RString& /* aUri */,

                                             TInt aErrorCode)

    {

    if (aErrorCode)

        {

        User::Leave(aErrorCode);

        }

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::OnEndPrefixMappingL

// This method is a notification of end of the scope of a prefix-URI mapping.

// This method is called after the corresponding DoEndElementL method.

// @param aPrefix is the Namespace prefix that was mapped.

// @param aErrorCode is the error code.

// If this is not KErrNone then special action may be required.

// ----------------------------------------------------------------------------

//

void CRsfwLockQueryParser::OnEndPrefixMappingL(const RString& /* aPrefix */,

                                           TInt aErrorCode)

    {

    if (aErrorCode)

        {

        User::Leave(aErrorCode);

        }

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::OnIgnorableWhiteSpaceL

// This method is a notification of ignorable whitespace in element content.

// @param aBytes are the ignored bytes from the document being parsed.

// @param aErrorCode is the error code.

// If this is not KErrNone then special action may be required.

// ----------------------------------------------------------------------------

//

void CRsfwLockQueryParser::OnIgnorableWhiteSpaceL(const TDesC8& /* aBytes */,

                                              TInt aErrorCode)

    {

    if (aErrorCode)

        {

        User::Leave(aErrorCode);

        }

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::OnSkippedEntityL

// This method is a notification of a skipped entity.

// If the parser encounters an external entity it does not need to expand it -

// it can return the entity as aName for the client to deal with.

// @param aName is the name of the skipped entity.

// @param aErrorCode is the error code.

// If this is not KErrNone then special action may be required.

// ----------------------------------------------------------------------------

//

void CRsfwLockQueryParser::OnSkippedEntityL(const RString& /* aName */,

                                        TInt aErrorCode)

    {

    if (aErrorCode)

        {

        User::Leave(aErrorCode);

        }

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::OnProcessingInstructionL

// This method is a receive notification of a processing instruction.

// @param aTarget is the processing instruction target.

// @param aData is the processing instruction data. If empty none was supplied.

// @param aErrorCode is the error code.

// If this is not KErrNone then special action may be required.

// ----------------------------------------------------------------------------

//

void CRsfwLockQueryParser::OnProcessingInstructionL(const TDesC8& /* aTarget */,

                                                const TDesC8& /* aData */,

                                                TInt aErrorCode)

    {

    if (aErrorCode)

        {

        User::Leave(aErrorCode);

        }

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::OnError

// This method indicates an error has occurred.

// @param aErrorCode is the error code

// ----------------------------------------------------------------------------

//

void CRsfwLockQueryParser::OnError(TInt aErrorCode)

    {

    DEBUGSTRING(("CRsfwLockQueryParser::OnError(%d)", aErrorCode));

    iError = aErrorCode;

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::GetExtendedInterface

// This method obtains the interface matching the specified uid.

// @return 0 if no interface matching the uid is found.

// Otherwise, the this pointer cast to that interface.

// @param aUid the uid identifying the required interface.

// ----------------------------------------------------------------------------

//

TAny* CRsfwLockQueryParser::GetExtendedInterface(const TInt32 /* aUid */)

    {

    return NULL;

    }

// ----------------------------------------------------------------------------

// CRsfwLockQueryParser::SetFileDavInfo

// Set a pointer to the directory information structure to be filled.

// ----------------------------------------------------------------------------

//

void CRsfwLockQueryParser::SetDavFileInfo(CRsfwDavFileInfo* aDavFileInfo)

    {

    iDavFileInfo = aDavFileInfo;

    }

TInt CRsfwLockQueryParser::GetLastError() 

	{

	return iError;

	}

//  End of File