/*
* Copyright (c) 2002 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:  Document structure validator.
*
*/


//  INCLUDE FILES
#include "CWPValidator.h"
#include "MWPElement.h"
#include "CWPParameter.h"
#include "CWPCharacteristic.h"
#include "WPEngineDebug.h"

// DATA TYPES
// Element in the validating table.
struct TMapping 
    {
    // The contained element type 
    TInt iTo;

    // Pointer to the validating table for the contained element
    const TMapping* iMapping;
    };

// CONSTANTS

// Validating table for unknown characteristics
const TMapping KMappingArrayNamedCharacteristic[] =
    {
        { KWPParameter, NULL },
        { KWPNamedCharacteristic, KMappingArrayNamedCharacteristic },
        { KWPElement, NULL }
    };

// Validating table for parameters only characteristics
const TMapping KMappingArrayParametersOnly[] =
    {
        { KWPParameter, NULL },
        { KWPNamedCharacteristic, KMappingArrayNamedCharacteristic },
        { KWPElement, NULL }
    };

// Validating table for PXPHYSICAL
const TMapping KMappingArrayPxPhysical[] =
    {
        { KWPParameter, NULL },
        { KWPPort, KMappingArrayParametersOnly },
        { KWPNamedCharacteristic, KMappingArrayNamedCharacteristic },
        { KWPElement, NULL }
    };

// Validating table for PXLOGICAL
const TMapping KMappingArrayPxLogical[] =
    {
        { KWPParameter, NULL },
        { KWPPxPhysical, KMappingArrayPxPhysical },
        { KWPPort, KMappingArrayParametersOnly },
        { KWPPxAuthInfo, KMappingArrayParametersOnly },
        { KWPNamedCharacteristic, KMappingArrayNamedCharacteristic },
        { KWPElement, NULL }
    };

// Validating table for WLAN
const TMapping KMappingArrayWLAN[] =
    {
        { KWPParameter, NULL },
        { KWPWepKey, KMappingArrayParametersOnly },
        { KWPElement, NULL }
    };

// Validating table for NAPDEF
const TMapping KMappingArrayNapDef[] =
    {
        { KWPParameter, NULL },
        { KWPValidity, KMappingArrayParametersOnly },
        { KWPNapAuthInfo, KMappingArrayParametersOnly },
        { KWPBearerInfo, KMappingArrayParametersOnly },
        { KWPDNSAddrInfo, KMappingArrayParametersOnly },
        { KWPWLAN, KMappingArrayWLAN },
        { KWPNamedCharacteristic, KMappingArrayNamedCharacteristic },
        { KWPElement, NULL }
    };

// Validating table for APPADDR
const TMapping KMappingArrayAppAddr[] =
    {
        { KWPParameter, NULL },
        { KWPPort, KMappingArrayParametersOnly },
        { KWPNamedCharacteristic, KMappingArrayNamedCharacteristic },
        { KWPElement, NULL }
    };

// Validating table for APPLICATION
const TMapping KMappingArrayApplication[] =
    {
        { KWPParameter, NULL },
        { KWPAppAddr, KMappingArrayAppAddr },
        { KWPAppAuth, KMappingArrayParametersOnly },
        { KWPResource, KMappingArrayParametersOnly },
        { KWPNamedCharacteristic, KMappingArrayNamedCharacteristic },
        { KWPElement, NULL }
    };

// Validating table for the document root
const TMapping KMappingArrayRoot[] =
    {
        { KWPPxLogical, KMappingArrayPxLogical },
        { KWPNapDef, KMappingArrayNapDef },
        { KWPBootstrap, KMappingArrayParametersOnly },
        { KWPVendorConfig, KMappingArrayParametersOnly },
        { KWPClientIdentity, KMappingArrayParametersOnly },
        { KWPAccess, KMappingArrayParametersOnly },
        { KWPApplication, KMappingArrayApplication },
        { KWPBearerInfo, KMappingArrayParametersOnly },
        { KWPWLAN, KMappingArrayParametersOnly },
        { KWPDNSAddrInfo, KMappingArrayParametersOnly },
        { KWPLoginScript, KMappingArrayParametersOnly },
        { KWPNamedCharacteristic, KMappingArrayNamedCharacteristic },
        { KWPElement, NULL }
    };

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

// -----------------------------------------------------------------------------
// CWPValidator::CWPValidator
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CWPValidator::CWPValidator()
    {
    iCurrentMapping = KMappingArrayRoot;
    iFlag = ETrue;
    }

// -----------------------------------------------------------------------------
// CWPValidator::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CWPValidator::ConstructL()
    {
    }

// -----------------------------------------------------------------------------
// CWPValidator::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CWPValidator* CWPValidator::NewL()
    {
    CWPValidator* self = NewLC();
    CleanupStack::Pop();
    
    return self;
    }

// -----------------------------------------------------------------------------
// CWPValidator::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CWPValidator* CWPValidator::NewLC()
    {
    CWPValidator* self = new( ELeave ) CWPValidator;
    
    CleanupStack::PushL( self );
    self->ConstructL();
    
    return self;
    }

// Destructor
CWPValidator::~CWPValidator()
    {
    iCurrentMapping = NULL;
    iCurrentElement = NULL;
    }

// -----------------------------------------------------------------------------
// CWPValidator::Visit
// -----------------------------------------------------------------------------
//
void CWPValidator::VisitL( CWPParameter& aParameter )
    {
    // Store the current mapping and element
    const TMapping* currentMapping = iCurrentMapping;
    const MWPElement* currentElement = iCurrentElement;

    DVA( "Validator: Mapping to parameter %d", aParameter.ID() );
    // Check if the mapping is valid
    MapToL( aParameter );
    DEBUG( "Validator: Exit" );

    // Restore the current mapping and element
    iCurrentMapping = currentMapping;
    iCurrentElement = currentElement;
    }

// -----------------------------------------------------------------------------
// CWPValidator::Visit
// -----------------------------------------------------------------------------
//
void CWPValidator::VisitL( CWPCharacteristic& aCharacteristic )
    {
    // Store the current mapping and element
    const TMapping* currentMapping = iCurrentMapping;
    const MWPElement* currentElement = iCurrentElement;

    DVA( "Validator: Mapping to characteristic %d", aCharacteristic.Type() );
    // Check if the mapping is valid
    MapToL( aCharacteristic );

    // Mapping is valid, so enter the characteristic
    if(iFlag)
    {
    aCharacteristic.AcceptL( *this );
    }
    DEBUG( "Validator: Exit" );

    // Restore the current mapping and element
    iCurrentMapping = currentMapping;
    iCurrentElement = currentElement;
    iFlag = ETrue;
    }

// -----------------------------------------------------------------------------
// CWPValidator::VisitLink
// -----------------------------------------------------------------------------
//
void CWPValidator::VisitLinkL( CWPCharacteristic& /*aLink*/ )
    {
    }

// -----------------------------------------------------------------------------
// CWPValidator::MapToL
// -----------------------------------------------------------------------------
//

void CWPValidator::MapToL( MWPElement& aTo )
    {
    TInt toType( aTo.Type() );

    for( TInt i( 0 ); iCurrentMapping[i].iTo != KWPElement; i++ )
        {
        if( iCurrentMapping[i].iTo == toType )
            {
            iCurrentMapping = iCurrentMapping[i].iMapping;
            iCurrentElement = &aTo;
            return;
            }
        }
    if ( Rangecheck( toType ) )
    {
    	iFlag = EFalse;
    	return;
    }

    DEBUG( "Validator: Error" );
    User::Leave( KErrCorrupt );
    }

TBool CWPValidator::Rangecheck(const TInt toType )
{
	if((toType != KWPElement) || (toType != KWPParameter) ||
	   (toType != KWPPxLogical ) || (toType != KWPPxPhysical) ||
	   (toType != KWPPort) || (toType != KWPValidity) ||
	   (toType != KWPNapDef) || (toType != KWPBootstrap) ||
	   (toType != KWPVendorConfig) || (toType != KWPClientIdentity) ||
	   (toType != KWPPxAuthInfo) || (toType != KWPNapAuthInfo) ||
	   (toType != KWPAccess) || (toType != KWPBearerInfo) ||
	   (toType != KWPDNSAddrInfo) || (toType != KWPWLAN) ||
	   (toType != KWPWepKey) || (toType != KWPPort1) ||
	   (toType != KWPApplication) || (toType != KWPAppAddr) ||
	   (toType != KWPAppAuth) || (toType != KWPClientIdentity1) ||
	   (toType != KWPResource) || (toType != KWPLoginScript) ||
	   (toType != KWPNamedCharacteristic))
	   return ETrue;
	else
	   return EFalse;
}

//  End of File