// 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:

// $Header$

// CCmdBase.cpp

// This file contains the implementation for miscellaneous CCmd*

// class' member functions. 

// rev:	mjdavey, symbian@mjdss.com, July 2002

// for:	Typhoon (7.0s) & JetStream (8.0)

// Include Files  

// 

//

#include "CCmdMisc.h"

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

CCmdCase* CCmdCase::NewL( TInt aCommandId, const TDesC& aKeyphrase )

//	These functions allocate a CASE command object and construct it.

{

CCmdCase* self = NewLC( aCommandId, aKeyphrase );

CleanupStack::Pop();

return self; 

}

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

CCmdCase* CCmdCase::NewLC( TInt aCommandId, const TDesC& aKeyphrase )

{

CCmdCase* self = new (ELeave) CCmdCase();

CleanupStack::PushL( self );

self->ConstructL( aCommandId, aKeyphrase );

return self;

}

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

CCmdCase::~CCmdCase ( )

//	This function destructs the CASE command object.

{

}

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

void CCmdCase::ConstructL(TInt          aCommandId,   // in: command identifier

													const TDesC&  aKeyphrase )  // in: beginning of the command name

//	This function constructs the CASE command object.

{

CCmdBase::ConstructL(aCommandId, aKeyphrase);

}

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

TBool CCmdCase::Recognize(const TDesC& aCommand)

//	This function overrides the CCmdBase::Recognize. 

{

// Recognize the command and extract the parameter=description.

TPtrC param;

TRAPD(ret, param.Set(ParamsL(aCommand)));

if (ret != KErrNone) 

	return EFalse;

// Check if this case was selected and set the CASE's StepOver

// flag and the command family's StepOver accordingly.

param.Set(TfrLex::Trim( param));

CCmdSelect *select = (CCmdSelect*)Family()->Command(ECmdSelect);

TBool selected = (select == NULL || select->Selected(param));

SetStepOver(!selected);

Family()->SetStepOver(!selected);

return ETrue;

}

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

TInt CCmdCase::ProcessL(const TDesC& aCommand)      // command line

//	This function parses and processes a CASE command line. As a matter of

//	fact, processing the CASE command does nothing (but see the Recognize).

{

// Complete the test machine - will then get the next cmd

Machine()->CompleteRequest();

TPtrC param;

TRAPD( ret, param.Set(ParamsL(aCommand)));

if (ret != KErrNone) 

	return Error(ret, KFmtErrInvalidCmd, &Keyphrase());

return KErrNone;

}

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

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

// CCmdEndCase

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

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

CCmdEndCase* CCmdEndCase::NewL( TInt aCommandId, const TDesC& aKeyphrase )

//	These functions allocate a END CASE command object and construct it.

{

CCmdEndCase* self = NewLC( aCommandId, aKeyphrase );

CleanupStack::Pop();

return self; 

}

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

CCmdEndCase* CCmdEndCase::NewLC( TInt aCommandId, const TDesC& aKeyphrase )

{

CCmdEndCase* self = new (ELeave) CCmdEndCase();

CleanupStack::PushL( self );

self->ConstructL( aCommandId, aKeyphrase );

return self;

}

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

CCmdEndCase::~CCmdEndCase()

{

}

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

void CCmdEndCase::ConstructL(TInt aCommandId,   // in: command identifier

														 const TDesC &aKeyphrase)  // in: beginning of the command name

{

CCmdBase::ConstructL(aCommandId, aKeyphrase);

}

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

TBool CCmdEndCase::Recognize( const TDesC& aCommand  )

//	This function overrides the CCmdBase::Recognize

{

// Recognize the command and extract the remainder (is ignored).

TPtrC param;

TRAPD( ret, param.Set( ParamsL( aCommand )) );

if ( ret != KErrNone ) 

	return EFalse;

// Set this END CASE command's StepOver as in command family

SetStepOver( Family()->StepOver() );

// Reset the command family's StepOver flag back to false i.e.

// commands will be processed starting from the next one.

Family()->SetStepOver( EFalse );

return ETrue;

}

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

TInt CCmdEndCase::ProcessL ( const TDesC& aCommand)      // command line

//	This function parses and processes a END CASE command line. As a matter

//	of fact, processing the END CASE command in here does nothing (but see

//	the Recognize).

{

// Complete the test machine - will then get the next cmd

Machine()->CompleteRequest();

TPtrC param;

TRAPD( ret, param.Set( ParamsL( aCommand )) );

if ( ret != KErrNone ) return Error(ret, KFmtErrInvalidCmd, &Keyphrase());

return ret; // = KErrNone

}

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

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

// CCmdSelect

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

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

CCmdSelect* CCmdSelect::NewL( TInt aCommandId, const TDesC& aKeyphrase )

//	These functions allocate a CCmdSelect command object and construct it.

{

CCmdSelect* self = NewLC( aCommandId, aKeyphrase );

CleanupStack::Pop();

return self; 

}

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

CCmdSelect* CCmdSelect::NewLC( TInt aCommandId, const TDesC& aKeyphrase )

{

CCmdSelect* self = new (ELeave) CCmdSelect();

CleanupStack::PushL( self );

self->ConstructL( aCommandId, aKeyphrase );

return self;

}

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

CCmdSelect::~CCmdSelect()

{

delete iSelector;

iSelector = NULL;

}

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

void CCmdSelect::ConstructL(TInt          aCommandId,   // in: command identifier

														const TDesC&  aKeyphrase )  // in: beginning of the command name

//	This function constructs the CCmdSelect command object.

{

CCmdBase::ConstructL(aCommandId, aKeyphrase);

iSelector = NULL; // This means SELECT ALL!

}

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

TInt CCmdSelect::ProcessL(const TDesC& aCommand)      // command line

//	This function parses and processes a CCmdSelect command line

{

// Complete the test machine

Machine()->CompleteRequest();

TPtrC param;

TRAPD(ret, param.Set(ParamsL(aCommand)));

if (ret != KErrNone)

	return Error(ret, TFR_KFmtErrBadCmd, &Keyphrase());

if (Family()->Switch(CCmdFamily::EParseOnly))

	return ret;

// This is the selector string.

param.Set(TfrLex::Trim(param));

// Delete old selector if any and make a new one.

if (iSelector != NULL)	

	delete iSelector;

iSelector = NULL; // This means ALL.

if (param.Length() > 0)

	{

	iSelector = param.Alloc();

	if (iSelector == NULL)

		{

		ret = KErrNoMemory;

		Printf(TFR_KFmtErrFailed, &Keyphrase(), ret);

		}

	}

return ret;

}

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

TPtrC CCmdSelect::Selector() const

//	This function gives the present selector

{

TPtrC selector = iSelector->Des();

return selector;

}

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

TBool CCmdSelect::Selected(const TDesC &aCandidate)

//	This function checks if a candidate is selected.

{

// Having no selector means select ALL.

if ( iSelector == NULL ) 

	return ETrue;

// Having empty selector means select NONE.

if ( iSelector->Length() == 0 ) 

	return EFalse;

// Selectors ALL and NONE are accepted as well.

if ( iSelector->Des().CompareF( _L("ALL"))  == 0 ) 

	return ETrue;

if ( iSelector->Des().CompareF( _L("NONE")) == 0 ) 

	return EFalse;

// Otherwise any match will do.

return (aCandidate.MatchF( iSelector->Des() ) != KErrNotFound);

}

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

//  End of File  

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