/*
* 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: 
*     WV Services tree data structures for Service Negotiation.
*     TImpsServices and TImpsFeature.
*
*/


#ifndef CImpsServices_H
#define CImpsServices_H

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


// *** FUNCTIONS ***

// Fundamental functions
const TInt KImpsServiceFunc     = 0x0001;
const TInt KImpsSearchFunc      = 0x0002;
const TInt KImpsInviteFunc      = 0x0004;

// Presence functions
const TInt KImpsContListFunc    = 0x0008;
const TInt KImpsPresAuthFunc    = 0x0010;
const TInt KImpsPresDeliverFunc = 0x0020;
const TInt KImpsAttListFunc     = 0x0040;

// IM Functions
const TInt KImpsIMSendFunc      = 0x0080;
const TInt KImpsIMReceiveFunc   = 0x0100;
const TInt KImpsIMAuthFunc      = 0x0200;

// Group functions
const TInt KImpsGroupMgmtFunc   = 0x0400;
const TInt KImpsGroupUseFunc    = 0x0800;
const TInt KImpsGroupAuthFunc   = 0x1000;

// Service value bitmap flags
// Use plus operation or method SetThisFlag to build a set of methods and
// bit mask or method IsThisFlagSet to check if a single method is supported.

const TInt KImpsServiceNone         = 0x0000;
const TInt KAllFuncs                = 0xFFFFFFFF;

// *** CAPABILITIES ***
// Named also sub-functions or elements in CSP definition

// Fundamental capability flags 
const TInt KImpsServiceGETSPI       = 0x0001;
const TInt KImpsServiceSRCH         = 0x0002;
const TInt KImpsServiceSTSRC        = 0x0004;
const TInt KImpsServiceINVIT        = 0x0008;
const TInt KImpsServiceCAINV        = 0x0010;

// Presence capability flags
const TInt KImpsServiceGCLI         = 0x0001;
const TInt KImpsServiceCCLI         = 0x0002;
const TInt KImpsServiceDCLI         = 0x0004;
const TInt KImpsServiceMCLS         = 0x0008;
const TInt KImpsServiceGETWL        = 0x0010;
const TInt KImpsServiceREACT        = 0x0020;
const TInt KImpsServiceCAAUT        = 0x0040;
const TInt KImpsServiceGETPR        = 0x0080;
const TInt KImpsServiceUPDPR        = 0x0100;
const TInt KImpsServiceCALI         = 0x0200;
const TInt KImpsServiceDALI         = 0x0400;
const TInt KImpsServiceGALS         = 0x0800;
const TInt KImpsServiceGETAUT       = 0x1000;  // WV 1.2

// IM capability flags
const TInt KImpsServiceMDELIV       = 0x0001;
const TInt KImpsServiceFWMSG        = 0x0002;
const TInt KImpsServiceSETD         = 0x0004;
const TInt KImpsServiceGETLM        = 0x0008;
const TInt KImpsServiceGETM         = 0x0010;
const TInt KImpsServiceREJCM        = 0x0020;
const TInt KImpsServiceNOTIF        = 0x0040;
const TInt KImpsServiceNEWM         = 0x0080;
const TInt KImpsServiceGLBLU        = 0x0100;
const TInt KImpsServiceBLENT        = 0x0200;

// Group capability flags
const TInt KImpsServiceCREAG        = 0x0001;
const TInt KImpsServiceDELGR        = 0x0002;
const TInt KImpsServiceGETGP        = 0x0004;
const TInt KImpsServiceSETGP        = 0x0008;
const TInt KImpsServiceSUBGCN       = 0x0010;
const TInt KImpsServiceGRCHN        = 0x0020;
const TInt KImpsServiceGETGM        = 0x0040;
const TInt KImpsServiceADDGM        = 0x0080;
const TInt KImpsServiceRMVGM        = 0x0100;
const TInt KImpsServiceMBRAC        = 0x0200;
const TInt KImpsServiceREJEC        = 0x0400;


const TInt KImpsMaxSapLen       = 255;
const TInt KImpsMaxUserIdLen    =  50;

// DATA TYPES
enum TImpsFeatures
    {
    //Features
    EFundamentalFeat = 1,
    EPresenceFeat,
    EIMFeat,
    EGroupFeat
    };

enum TImpsFunctions
    {
    //Functions
    EServiceFunc = KImpsServiceFunc,
    ESearchFunc = KImpsSearchFunc,
    EInviteFunc = KImpsInviteFunc ,
    EContListFunc = KImpsContListFunc, 
    EPresenceAuthFunc = KImpsPresAuthFunc,
    EPresenceDeliverFunc = KImpsPresDeliverFunc,
    EAttrListFunc = KImpsAttListFunc,
    EIMSendFunc = KImpsIMSendFunc,
    EIMReceiveFunc = KImpsIMReceiveFunc,
    EIMAuthFunc = KImpsIMAuthFunc,
    EGroupMgmtFunc = KImpsGroupMgmtFunc,
    EGroupUseFunc = KImpsGroupUseFunc,
    EGroupAuthFunc = KImpsGroupAuthFunc,
    EAllFuncs = KAllFuncs
    };

// General Feature class
class TImpsFeature
    {
    public:

        /**
        * Feature type accessor
        * @return feature
        */
        inline TImpsFeatures Feature( ) const;

        /**
        * Feature type mutator
        * @return aFeature feature
        */
        void SetFeature( TImpsFeatures aFeature );

        /**
        * Is this element active
        * @return True if this element exists
        */
        inline TBool IsSupported( ) const;

        /**
        * Feature activity mutator
        * @param aVal True if this element exists
        */
        inline void SetSupported( TBool aVal );

        /**
        * Function accessor
        * @param aFunc function 
        * @return EImpsTrue if the function exists
        */
        inline TBool Function( TImpsFunctions aFunc );

        /**
        * Function mutator
        * @param aFunc function 
        * @param aVal new value for the function
        */
        inline void SetFunction( TImpsFunctions aFunc, TBool aVal );

        /**
        * Capability (sub-function) accessor
        * @param aFunc sub-function(s) 
        * @return True if this element(s) exists
        */
        inline TBool Capability( TInt aFunc );

        /**
        * Capability (sub-function) mutator.
        * You should set corresponding Function with SetFunction
        * @param aCapa sub-function(s) 
        * @param aVal sub-function value 
        */
        inline void SetCapability( TInt aCapa, TBool aVal );

        /**
        * Reset
        * Functions and capabilities are cleaned expect if aAll is true.
        * @param aAll if true then all functions and capabilities are set on.
        */
        IMPORT_C void Reset( TBool aAll = EFalse );

        /**
        * Copy data
        */
        IMPORT_C void Copy( TImpsFeature& aCopy );

    private:

        /**
        * general bit map flag accessor
        * @param aValues service values
        * @prama aFlag single service flag
        * @return ETrue if the flag is set on
        */
        inline TBool IsThisFlagSet( TInt aValues, TInt aFlag ) const;

        /**
        * General bit map flag mutator
        * @param aValues service values
        * @parama aFlag single service flag
        * @param aValue new value for aFlag in aValue
        */
        inline void SetThisFlag( 
            TInt &aValues, 
            TInt aFlag,
            TBool aValue);

    private:    // Data

        TImpsFeatures   iFeature;
        TBool           iOn;
        TInt            iFunctions;
        TInt            iCapabilities;
    };

/**
*  WV Services tree data structure 
*/
class TImpsServices 
    {
    public:  // Constructors and destructor
        
        /**
        * C++ default constructor.
        */
        IMPORT_C TImpsServices();

        
    public: // New functions

        
        /**
        * Reset
        * Clean everyting expect if aAll is true.
        * @param aAll if true then all features, 
        * functions and capabilities are set on.
        */
        IMPORT_C void Reset( TBool aAll = EFalse );

        /**
        * Copy data
        */
        IMPORT_C void Copy( TImpsServices& aCopy );
      
        /**
        * Feature accessor
        */
        IMPORT_C TImpsFeature* Feature( TImpsFeatures aFeature );

    private:    // Data

        TImpsFeature            iFundamental;
        TImpsFeature            iPresence;
        TImpsFeature            iIM;
        TImpsFeature            iGroup;

    };

/**
* general bit map flag accessor
* @param aValues service values
* @prama aFlag single service flag
* @return ETrue if the flag is set on
*/
inline TBool TImpsFeature::IsThisFlagSet( TInt aValues, TInt aFlag ) const
    {
    return ( aValues & aFlag ? ETrue : EFalse );
    }

/**
* General bit map flag mutator
* @param aValues service values
* @parama aFlag single service flag
* @param aValue new value for aFlag in aValue
*/
inline void TImpsFeature::SetThisFlag( 
    TInt &aValues, 
    TInt aFlag,
    TBool aValue)
    {
    aValues = ( aValues & ~aFlag ) | ( aValue ? aFlag : 0x0000 );
    }

/**
* Feature type accessor
* @return feature
*/
inline TImpsFeatures TImpsFeature::Feature( ) const
    {
    return iFeature;
    }

/**
* Is this element active
* @return True if this element exists
*/
inline TBool TImpsFeature::IsSupported( ) const
    {
    return iOn;
    }

/**
* Feature activity mutator
* @param aVal True if this element exists
*/
inline void TImpsFeature::SetSupported( TBool aVal )
    {
    iOn = aVal;
    }

/**
* Function mutator
* @param aFunc function 
* @param aVal new value for the function
*/
inline void TImpsFeature::SetFunction( TImpsFunctions aFunc, TBool aVal )
    {
    SetThisFlag( iFunctions, aFunc, aVal );
    }

/**
* Function accessor
* @param aFunc function 
* @return EImpsTrue if the function exists
*/
inline TBool TImpsFeature::Function( TImpsFunctions aFunc )
    {
    return IsThisFlagSet( iFunctions, aFunc );
    }

/**
* Capability (sub-function) mutator.
* You should set corresponding Function with SetFunction
* @param aCapa sub-function(s) 
* @param aVal sub-function value 
*/
inline void TImpsFeature::SetCapability( TInt aCapa, TBool aVal )
    {
    SetThisFlag( iCapabilities, aCapa, aVal );
    }

/**
* Capability (sub-function) accessor
* @param aFunc sub-function(s) 
* @return True if this element(s) exists
*/
inline TBool TImpsFeature::Capability( TInt aCapa )
    {
    return IsThisFlagSet( iCapabilities, aCapa );
    }

/**
*  CspSession identifier
*/
class TImpsCspIdentifier 
    {
    public:  // Constructors and destructor
        
        /**
        * C++ default constructor.
        */
        IMPORT_C TImpsCspIdentifier();

        /**
        * Constructor
        */
        IMPORT_C TImpsCspIdentifier( const TDesC& aSap, 
                                     const TDesC& aUserId );

    public: // New functions
      
        /**
        * Sap accessor
        * Leaves with KErrNotFound if no value
        * @return SAP URI 
        */
        inline TPtrC Sap( );

        /**
        * UserId accessor
        * Leaves with KErrNotFound if no value
        * @return UserId 
        */
        inline TPtrC UserId( );

        /**
        * Sap mutator
        * @param aSap SAP URI, may include port number  
        */
        inline void SetSapL( const TDesC& aSap );

        /**
        * UserId mutator
        * @param aUserId UserId, (max 50 characters)  
        */
        inline void SetUserIdL( const TDesC& aUserId );

    private:    // Data

        TBuf<KImpsMaxSapLen>            iSAP;
        TBuf<KImpsMaxUserIdLen>         iUserId;
    };

/**
* Sap accessor
* Leaves with KErrNotFound if no value
* @return SAP URI 
*/
inline TPtrC TImpsCspIdentifier::Sap( )
    {
    return iSAP;
    }
    
/**
* UserId accessor
* Leaves with KErrNotFound if no value
* @return UserId 
*/
inline TPtrC TImpsCspIdentifier::UserId( )
    {
    return iUserId;
    }
    
/**
* Sap mutator
* @param aSap SAP URI, may include port number  
*/
inline void TImpsCspIdentifier::SetSapL( const TDesC& aSap )
    {
    iSAP = aSap;
    }
    
/**
* UserId mutator
* @param aUserId UserId, (max 50 characters)  
*/
inline void TImpsCspIdentifier::SetUserIdL( const TDesC& aUserId )
    {
    iUserId = aUserId;
    }
    
#endif