/*
* Copyright (c) 2002-2009 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:  It is responsible of parsing of GSM specified supplementary 
*                service requests.
*
*/


#ifndef CPHONEGSMSSPARSER_H
#define CPHONEGSMSSPARSER_H

// INCLUDES
#include    <e32base.h>
#include    "cphonegsmparserbase.h" 

// CONSTANTS

/*
* SUPPLEMENTARY SERVICE UIDS
*/

/*
* Now follows uids for all supported supplementary services.
*/
const TUint32 KPhoneUidForwardingAll = 
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 0 );
const TUint32 KPhoneUidForwardingAllConditional = 
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 1 );
const TUint32 KPhoneUidForwardingUnconditional = 
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 2 );
const TUint32 KPhoneUidForwardingNoReply = 
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 3 );
const TUint32 KPhoneUidForwardingNotReachable = 
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 4 );
const TUint32 KPhoneUidForwardingBusy = 
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 5 );
const TUint32 KPhoneUidBarringAllOutgoingCalls = 
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 6 );
const TUint32 KPhoneUidBarringAllIncomingCalls =
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 7 );
const TUint32 KPhoneUidBarringAllServices =
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 8 );
const TUint32 KPhoneUidBarringAllOutgoingInternationalCalls =
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 9 );
const TUint32 KPhoneUidBarringAllOutgoingInternationalCallsExceptHome =
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 10 );
const TUint32 KPhoneUidBarringAllOutgoingServices = 
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 11 );
const TUint32 KPhoneUidBarringAllIncomingCallsWhenRoaming =
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 12 );
const TUint32 KPhoneUidBarringAllIncomingServices = 
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 13 );
const TUint32 KPhoneUidWaiting =
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 14 );
const TUint32 KPhoneUidCallingLineIdentificationPresentation =
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 15 );
const TUint32 KPhoneUidCallingLineIdentificationRestriction =
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 16 );
const TUint32 KPhoneUidConnectedLinePresentation =
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 17 );
const TUint32 KPhoneUidConnectedLinePresentationRestriction =
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 18 );
const TUint32 KPhoneUidPassword =
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 19 );
const TUint32 KPhoneUidCallingNamePresentation =
    PHONE_MAKE_UID( KPhoneGsmUidSupplementaryService, 20 );

/**
* It defines the maximum lenght of service code.
*/
const TInt KPhoneGsmSsServiceCodeMaxLength = 5;

// CLASS DECLARATION

/**
* It is responsible of parsing GSM specified supplementary services that
* are supported.
*
* @since 1.0
* @lib phoneparser.lib
*/
NONSHARABLE_CLASS( CPhoneGsmSsParser )
    : public CPhoneGsmParserBase
    {
    public: // Types

        /**
        * Enumeration for different service types.
        */
        enum TServiceType
            {
            EServiceActivation,
            EServiceDeactivation,
            EServiceInterrogation,
            EServiceRegistration,
            EServiceErasure
            };

        /** 
        * Enumeration for different syntax.
        *
        * ESyntaxNotAllowed
        *   Not allowed.
        *
        * ESyntaxNoParameters
        *   No parameters. 
        *
        *     SS_code#
        *
        * ESyntaxEmptyOrBasicCode
        *   No parameters or empty and basic code.
        *
        *     SS_code# or SS_code**BB#             
        *
        * ESyntaxNumberOptBasicCodeOptTimer
        *   Number parameter or number parameter and basic code or
        *   number parameter and basic code and timer or number parameter
        *   and timer.
        *
        *     SS_code*NN# or SS_code*NN*BB# or SS_code*NN*BB*TT# or
        *     SS_code*NN**TT#
        *
        * ESyntaxNumberOptBasicCode
        *   Number parameter or number parameter and basic code.
        *
        *     SS_code*NN# or SS_code*NN*BB#
        *
        * ESyntaxPasswordOptBasicCode
        *   Password or password and basic code. 
        *
        *     SS_code*PPPP# or SS_code*PPPP*BB#
        *
        * ESyntaxOptGroupCodePasswordNewPasswordNewPassword
        *
        *   Register group code and password and new password and 
        *   new password. Or same with empty register group.
        *
        *     SS_code*xxx*PPPP*WWWW*WWWW#         
        *     SS_code**PPPP*WWWW*WWWW#
        *
        * ESyntaxEmptyOrBasicCode2    
        *   Empty or Basic code 
        *
        *     SS_code# or SS_code*BB#
        */
        enum TServiceSyntax
            {
            ESyntaxNotAllowed,
            ESyntaxNoParameters, 
            ESyntaxEmptyOrBasicCode, 
            ESyntaxNumberOptBasicCodeOptTimer,
            ESyntaxNumberOptBasicCode,
            ESyntaxPasswordOptBasicCode,
            ESyntaxOptGroupCodePasswordNewPasswordNewPassword,
            ESyntaxEmptyOrBasicCode2
            };

    public:  // Constructors and destructor      
        
        /**
        * Two-phased constructor.
        */
        static CPhoneGsmSsParser* NewLC();
        
        /**
        * Destructor.
        */
        ~CPhoneGsmSsParser();

    public: // New functions
        

        /**
        * Pack data to integer.
        *
        * @param aResult It will contain packed data.
        * @param aType type of service.
        * @param aSyntax syntax of service.
        */
        static void PackData(
            TUint& aResult,
            TServiceType aType,
            TServiceSyntax aSyntax );       

        /**
        * Unpack data from integer.
        *
        * @param aData packed data.
        * @param aType type of service.
        * @param aSyntax syntax of service.
        */
        static void UnpackData(
            TUint aData,
            TServiceType& aType,
            TServiceSyntax& aSyntax );
        
// from base class CPhoneGsmParserBase    
        
        /**
         * From CPhoneGsmParserBase.
         * Parses ss strings.
         *
         * @param aString string to be parser.
         * @param aResult It will contain result.
         * @param aOptions It contains options.
         * @return ETrue iff string parsed successfully.
         */
         TBool ParseL(
                 const TDesC& aString, 
                 CPhoneGsmParserResult& aResult,
                 CPhoneGsmOptionContainerBase& aOptions );
        
    private:

        /**
        * C++ default constructor.
        */
        CPhoneGsmSsParser();

        /**
        * By default Symbian OS constructor is private.
        */
        void ConstructL();

        /**
        * Handle parameters.
        */
        TBool HandleParametersL( 
            TLex& aInput, 
            CPhoneGsmParserResult& aResult,
            TServiceSyntax aSyntax );

        /**
        * Handle "not allowed" syntax.
        */
        TBool HandleNotAllowedL( 
            TLex& aInput, 
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "no more parameters" syntax.
        */ 
        TBool HandleNoParametersL( 
            TLex& aInput, 
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "empty or basic code" syntax.
        */
        TBool HandleEmptyOrBasicCodeL( 
            TLex& aInput,
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "number optionally basic code and timer" syntax.
        */
        TBool HandleNumberOptBasicCodeOptTimerL(
            TLex& aInput,
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "number optionally basic code" syntax.
        */
        TBool HandleNumberOptBasicCodeL(
            TLex& aInput,
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "password optionally basic code" syntax.
        */
        TBool HandlePasswordOptBasicCodeL(
            TLex& aInput,
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "optionally group code, then old password and new
        * password twice" syntax.
        */
        TBool HandleOptGroupCodePasswordNewPasswordNewPasswordL(
            TLex& aInput,
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "empty or basic code" syntax.
        */
        TBool HandleEmptyOrBasicCode2L(
            TLex& aInput,
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "empty parameter" syntax.
        */
        TBool HandleEmptyParameterL( 
            TLex& aInput,
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "basic code" syntax.
        */
        TBool HandleBasicCodeL( 
            TLex& aInput,
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "directory number" syntax.
        */
        TBool HandleNumberL( 
            TLex& aInput,
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "timer" syntax.
        */
        TBool HandleTimerL( 
            TLex& aInput,
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "password" syntax.
        */
        TBool HandlePasswordL( 
            TLex& aInput,
            CPhoneGsmParserResult& aResult );

        /**
        * Handle "group code" syntax.
        */
        TBool HandleGroupCodeL( 
            TLex& aInput,
            CPhoneGsmParserResult& aResult );

        /**
        * Check basic service code.
        */
        TBool CheckBasicCode( const TDesC& aCode );

        /**
        * Check 'no reply timer'
        */
        TBool CheckTimer( const TDesC& aCode );

        /**
        * Check password group code.
        */ 
        TBool CheckGroupCode( const TDesC& aCode );

        /**
        * Find string (starting from current position) that 
        * contains characters from given string. 
        *
        * (note that empty string may be returned).
        */
        static TPtrC FindString( 
            TLex& aInput,
            const TDesC& aAllowedCharacters );

        /**
        * Add a new service.
        *
        * SHOULD ONLY BE USED DURING CONSTRUCTION.
        *
        * Panics if invalid service description is passed.
        *
        * @param aService It is service description.
        * @param aUid It is uid for the service.
        */
        void AddL( const TDesC& aService, TUint aUid );

        /**
        * Add a new service.
        *
        * SHOULD ONLY BE USED DURING CONSTRUCTION.
        */
        void AddServiceL( 
            const TDesC& aServiceCode,
            TServiceSyntax aActivation,
            TServiceSyntax aDeactivation,
            TServiceSyntax aInterrogation,
            TServiceSyntax aRegistration,
            TServiceSyntax aErasure,
            TUint aUid );

        /**
        * Get next number as descriptor.
        *
        * ONLY TO BE USED DURING SERVICE DESCRIPTION PARSING.
        *
        * Panics if next character (not a space) does not start 
        * a new number or the number is invalid.
        *
        * @param aLex It is lex.
        * @return Returns number.
        */
        static TPtrC NextNumber( TLex& aLex );

        /**
        * Get next number as value.
        *
        * ONLY TO BE USED DURING SERVICE DESCRIPTION PARSING.
        *
        * Panics if next character (not a space) does not start 
        * a new number or the number is invalid.
        *
        * @param aLex It is lex.
        * @return Returns number as value.
        */
        static TUint NextNumberAsValue( TLex& aLex );       

        /**
        * Converts to service syntax.
        *
        * @param aService It is numerical value of service syntax.
        * @return Returns service syntax corresponding to value.
        */
        static TServiceSyntax ConvertToServiceSyntax( TUint aService );

    private:    // Data

        /**
        * It is type for service code.
        */
        typedef TBuf< KPhoneGsmSsServiceCodeMaxLength > TServiceCode;
    
        /**
        * It defines structure containing information about a service.
        */
        class TServiceInfo
            {
            public:
                TServiceCode iCode;
                TServiceSyntax iActivation;
                TServiceSyntax iDeactivation;
                TServiceSyntax iInterrogation;
                TServiceSyntax iRegistration;
                TServiceSyntax iErasure;
                TUint iUid;
            };

        // Type for service code array.
        typedef CArrayFixFlat< TServiceInfo > CServiceArray;

        // Owned array of service codes.
        CServiceArray* iArray;

    };

#endif      // CPHONEGSMSSPARSER_H
            
// End of File