// server_command.cpp

// 

// Copyright (c) 2009 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include <fshell/ioutils.h>

#include <fshell/line_editor.h>

#include "command_base.h"

using namespace IoUtils;

//

// Constants.

//

_LIT(KTab, "\t");

_LIT(KSpace, " ");

_LIT(KNewLine, "\r\n");

_LIT(KHelpCommandName, "help");

// used for sorting RArray<TPtrC>'s

TInt PtrOrder(const TPtrC& aDennis, const TPtrC& aGnasher)

	{

	return aDennis.Compare(aGnasher);

	}

//

// TServerCommandId.

//

EXPORT_C TServerCommandId::TServerCommandId()

	: iId(0)

	{

	}

EXPORT_C TServerCommandId::TServerCommandId(TUint aValue)

	: iId(aValue)

	{

	}

EXPORT_C TUint TServerCommandId::Value() const

	{

	return iId;

	}

EXPORT_C void TServerCommandId::Set(const TServerCommandId& aId)

	{

	iId = aId.iId;

	}

EXPORT_C TBool TServerCommandId::operator==(const TServerCommandId& aId) const

	{

	return (iId == aId.iId);

	}

//

// CServerCommandBase.

//

EXPORT_C CServerCommandBase::~CServerCommandBase()

	{

	}

EXPORT_C const TServerCommandId& CServerCommandBase::Id() const

	{

	return iId;

	}

EXPORT_C void CServerCommandBase::SetId(const TServerCommandId& aId)

	{

	iId.Set(aId);

	}

EXPORT_C void CServerCommandBase::SetFactory(CServerCommandFactory& aFactory)

	{

	iFactory = &aFactory;

	}

EXPORT_C CServerCommandBase::CServerCommandBase()

	{

	}

EXPORT_C CServerCommandBase::CServerCommandBase(TUint aFlags)

	: CCommandBase(aFlags)

	{

	}

EXPORT_C CServerCommandFactory& CServerCommandBase::Factory()

	{

	__ASSERT_ALWAYS(iFactory, Panic(ENoFactory));

	return *iFactory;

	}

EXPORT_C void CServerCommandBase::PrintList(TRefByValue<const TDesC> aFmt, VA_LIST& aList)

	{

	if (iReporter)

		{

		iReporter->ReportList(iId, aFmt, aList);

		}

	else

		{

		CCommandBase::PrintList(aFmt, aList);

		}

	}

EXPORT_C void CServerCommandBase::PrintList(TRefByValue<const TDesC8> aFmt, VA_LIST& aList)

	{

	if (iReporter)

		{

		iReporter->ReportList(iId, aFmt, aList);

		}

	else

		{

		CCommandBase::PrintList(aFmt, aList);

		}

	}

EXPORT_C void CServerCommandBase::PrintErrorList(TInt aError, TRefByValue<const TDesC> aFmt, VA_LIST& aList)

	{

	if (iReporter)

		{

		iReporter->ReportErrorList(iId, aError, aFmt, aList);

		}

	else

		{

		CCommandBase::PrintErrorList(aError, aFmt, aList);

		}

	}

EXPORT_C void CServerCommandBase::PrintWarningList(TRefByValue<const TDesC> aFmt, VA_LIST& aList)

	{

	if (iReporter)

		{

		iReporter->ReportWarningList(iId, aFmt, aList);

		}

	else

		{

		CCommandBase::PrintWarningList(aFmt, aList);

		}

	}

void CServerCommandBase::SetReporter(MServerCommandReporter* aReporter)

	{

	iReporter = aReporter;

	}

//

// CHelpCommand.

//

NONSHARABLE_CLASS(CHelpCommand) : public CServerCommandBase

	{

public:

	static CServerCommandBase* NewLC();

	~CHelpCommand();

	static const TDesC& NameS();

private:

	CHelpCommand();

	void ConstructL();

	void GenerateTextL(const CServerCommandFactory& aFactory, TInt aIndent = 0);

	HBufC* FullCommandNameLC() const;

	void Write(TInt aIndent, const TDesC& aCommandName);

private: // From CCommandBase.

	virtual const TDesC& Name() const;

	virtual const TDesC& Description() const;

	virtual void DoRunL();

private:

	CTextBuffer* iBuffer;

	CTextFormatter* iFormatter;

	RArray<TPtrC> iCommandNameStack;

	RFile iPodIndex;

	};

CServerCommandBase* CHelpCommand::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CHelpCommand::~CHelpCommand()

	{

	delete iBuffer;

	delete iFormatter;

	iPodIndex.Close();

	iCommandNameStack.Close();

	}

const TDesC& CHelpCommand::NameS()

	{

	return KHelpCommandName;

	}

CHelpCommand::CHelpCommand()

	{

	}

void CHelpCommand::ConstructL()

	{

	BaseConstructL();

	}

const TDesC& CHelpCommand::Name() const

	{

	return KHelpCommandName;

	}

const TDesC& CHelpCommand::Description() const

	{

	_LIT(KDescription, "List the commands the amsrv supports.");

	return KDescription;

	}

void CHelpCommand::GenerateTextL(const CServerCommandFactory& aFactory, TInt aIndent)

	{

	RArray<TPtrC> commands;

	CleanupClosePushL(commands);

	aFactory.ListCommandsL(commands);

	commands.Sort(TLinearOrder<TPtrC>(PtrOrder));

	const TInt numCommands = commands.Count();

	for (TInt i = 0; i < numCommands; ++i)

		{

		const TDesC& commandName = commands[i];

		Write(aIndent, commandName);

		const CServerCommandConstructor& cmnd = aFactory.GetSubCommandL(commandName);

		if (cmnd.IsFactory())

			{

			GenerateTextL((const CServerCommandFactory&)cmnd, aIndent+1);

			}

		}

	CleanupStack::PopAndDestroy();

	}

HBufC* CHelpCommand::FullCommandNameLC() const

	{

	const TInt numCommands = iCommandNameStack.Count();

	TInt length = 0;

	for (TInt i = 0; i < numCommands; ++i)

		{

		length += iCommandNameStack[i].Length();

		if (i > 0)

			{

			++length;

			}

		}

	HBufC* name = HBufC::NewLC(length);

	TPtr namePtr(name->Des());

	for (TInt i = 0; i < numCommands; ++i)

		{

		if (i > 0)

			{

			namePtr.Append('_');

			}

		namePtr.Append(iCommandNameStack[i]);

		}

	return name;

	}

void CHelpCommand::Write(TInt aIndent, const TDesC& aCommandName)

	{

	_LIT(KIndent, "  ");

	if (iBuffer)

		{

		for (TInt j=0; j<aIndent; ++j)

			{

			iBuffer->AppendL(KIndent);

			}

		iBuffer->AppendL(aCommandName);

		iBuffer->AppendL(KTab);

		}

	else

		{

		for (TInt j=0; j<aIndent; ++j)

			{

			CCommandBase::Write(KIndent);

			}

		CCommandBase::Write(aCommandName);

		CCommandBase::Write(KNewLine);

		}

	}

void CHelpCommand::DoRunL()

	{

	if (Stdout().AttachedToConsole())

		{

		iBuffer = CTextBuffer::NewL(0x100);

		iFormatter = CTextFormatter::NewL(Stdout());

		}

	GenerateTextL(Factory());

	if (iBuffer)

		{

		iFormatter->ColumnizeL(0, 2, iBuffer->Descriptor());

		CCommandBase::Write(iFormatter->Descriptor());

		}

	CCommandBase::Write(_L("\r\n"));

	}

//

// CRootCommand.

//

NONSHARABLE_CLASS(CRootCommand) : public CBranchCommandBase

	{

public:

	static CRootCommand* NewL(CServerCommandFactory& aFactory);

	~CRootCommand();

private:

	CRootCommand();

	void ConstructL(CServerCommandFactory& aFactory);

private: // From CCommandBase.

	virtual const TDesC& Name() const;

	virtual const TDesC& Description() const;

private: // From CAmCmndParent.

	virtual const TDesC& TypeDescription();

	};

CRootCommand* CRootCommand::NewL(CServerCommandFactory& aFactory)

	{

	CRootCommand* root = new(ELeave)CRootCommand();

	CleanupStack::PushL(root);

	root->ConstructL(aFactory);

	CleanupStack::Pop(root);

	return root;

	}

CRootCommand::~CRootCommand()

	{

	}

CRootCommand::CRootCommand()

	{

	}

void CRootCommand::ConstructL(CServerCommandFactory& aFactory)

	{

	SetFactory(aFactory);

	}

const TDesC& CRootCommand::Name() const

	{

	_LIT(KCommandName, "root");

	return KCommandName;

	}

const TDesC& CRootCommand::Description() const

	{

	_LIT(KDescription, "A pseudo-command that is the ancestor of all other commands available in this server. Not intended to be run directly.");

	return KDescription;

	}

const TDesC& CRootCommand::TypeDescription()

	{

	return KNullDesC;

	}

//

// CServerBase.

//

EXPORT_C CServerBase::~CServerBase()

	{

	delete iLineEditor;

	delete iFactory;

	}

EXPORT_C CServerBase::CServerBase(TUint aFlags, const TDesC& aPrompt, const TDesC& aCommandHistoryFileName)

	: CCommandBase(aFlags), iPrompt(aPrompt), iCommandHistoryFileName(aCommandHistoryFileName), iWriterAdaptor(Stdout())

	{

	}

EXPORT_C CServerCommandFactory& CServerBase::Factory()

	{

	return *iFactory;

	}

EXPORT_C void CServerBase::Exit(TInt aError)

	{

	iExitReason = aError;

	iExit = ETrue;

	}

EXPORT_C void CServerBase::BaseConstructL()

	{

	CCommandBase::BaseConstructL();

	}

EXPORT_C void CServerBase::DoRunL()

	{

	iFactory = CServerCommandFactory::NewL(this, Cif());

	iLineEditor = CLineEditor::NewL(FsL(), iWriterAdaptor, *this, *iFactory, iCommandHistoryFileName);

	InitializeL();

	RProcess::Rendezvous(KErrNone);

	do

		{

		CheckNewConsoleLine();

		Write(iPrompt);

		ParseLineL(NextLineL());

		}

		while (!iExit);

	Complete(iExitReason);

	}

EXPORT_C void CServerBase::PrintList(TRefByValue<const TDesC> aFmt, VA_LIST& aList)

	{

	TOverflowTruncate overflow;

	TBuf<0x100> buf;

	buf.AppendFormatList(aFmt, aList, &overflow);

	Report(TServerCommandId(), buf);

	}

EXPORT_C void CServerBase::PrintList(TRefByValue<const TDesC8> aFmt, VA_LIST& aList)

	{

	TOverflowTruncate8 overflow;

	TBuf8<0x100> buf;

	buf.AppendFormatList(aFmt, aList, &overflow);

	Report(TServerCommandId(), buf);

	}

EXPORT_C void CServerBase::PrintErrorList(TInt aError, TRefByValue<const TDesC> aFmt, VA_LIST& aList)

	{

	if (!iErrorReported)

		{

		TOverflowTruncate overflow;

		TBuf<0x100> buf;

		buf.AppendFormatList(aFmt, aList, &overflow);

		ReportError(TServerCommandId(), aError, buf);

		iErrorReported = ETrue;

		}

	}

EXPORT_C void CServerBase::PrintWarningList(TRefByValue<const TDesC> aFmt, VA_LIST& aList)

	{

	TOverflowTruncate overflow;

	TBuf<0x100> buf;

	buf.AppendFormatList(aFmt, aList, &overflow);

	ReportWarning(TServerCommandId(), buf);

	}

EXPORT_C void CServerBase::Report(const TServerCommandId& aId, TRefByValue<const TDesC> aFmt, ...)

	{

	VA_LIST list;

	VA_START(list, aFmt);

	ReportList(aId, aFmt, list);

	VA_END(list);

	}

EXPORT_C void CServerBase::ReportList(const TServerCommandId& aId, TRefByValue<const TDesC> aFmt, VA_LIST& aList)

	{

	TOverflowTruncate overflow;

	TBuf<0x100> buf;

	buf.AppendFormatList(aFmt, aList, &overflow);

	Report(aId, buf);

	}

EXPORT_C void CServerBase::Report(const TServerCommandId& aId, TRefByValue<const TDesC8> aFmt, ...)

	{

	VA_LIST list;

	VA_START(list, aFmt);

	ReportList(aId, aFmt, list);

	VA_END(list);

	}

EXPORT_C void CServerBase::ReportList(const TServerCommandId& aId, TRefByValue<const TDesC8> aFmt, VA_LIST& aList)

	{

	TOverflowTruncate8 overflow;

	TBuf8<0x100> buf;

	buf.AppendFormatList(aFmt, aList, &overflow);

	Report(aId, buf);

	}

EXPORT_C void CServerBase::ReportWarning(const TServerCommandId& aId, TRefByValue<const TDesC> aFmt, ...)

	{

	VA_LIST list;

	VA_START(list, aFmt);

	ReportWarningList(aId, aFmt, list);

	VA_END(list);

	}

EXPORT_C void CServerBase::ReportWarningList(const TServerCommandId& aId, TRefByValue<const TDesC> aFmt, VA_LIST& aList)

	{

	TOverflowTruncate overflow;

	TBuf<0x100> buf;

	buf.AppendFormatList(aFmt, aList, &overflow);

	ReportWarning(aId, buf);

	}

EXPORT_C void CServerBase::ReportError(const TServerCommandId& aId, TInt aError, TRefByValue<const TDesC> aFmt, ...)

	{

	VA_LIST list;

	VA_START(list, aFmt);

	ReportErrorList(aId, aError, aFmt, list);

	VA_END(list);

	}

EXPORT_C void CServerBase::ReportErrorList(const TServerCommandId& aId, TInt aError, TRefByValue<const TDesC> aFmt, VA_LIST& aList)

	{

	if (!iErrorReported)

		{

		TOverflowTruncate overflow;

		TBuf<0x100> buf;

		buf.AppendFormatList(aFmt, aList, &overflow);

		ReportError(aId, aError, buf);

		iErrorReported = ETrue;

		}

	}

EXPORT_C void CServerBase::LeoHandleLine(const TDesC& aLine)

	{

	iLine = aLine;