// ioutils.h

// 

// Copyright (c) 2005 - 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

//

#ifndef __IOUTILS_H__

#define __IOUTILS_H__

#include <e32std.h>

#include <e32keys.h>

#include <e32base.h>

#include <e32hashtab.h>

#include <f32file.h>

#include <fshell/iocli.h>

#include <fshell/iocons_writer.h>

#include <fshell/line_editor_observer.h>

class CColorConsoleBase;

namespace IoUtils

	{

const TUint KEnvironmentProcessSlot		= 15;

const TUint KDllCommandLineProcessSlot	= 14;

const TUint KDllNameToLoadProcessSlot	= 13;

const TUint KPipsCommandNameProcessSlot = 14;

const TUint KPipsCommandLineProcessSlot = 13;

const TUint KValueTypeBool         		= 0;

const TUint KValueTypeInt          		= 1;

const TUint KValueTypeUint         		= 2;

const TUint KValueTypeString       		= 3;

const TUint KValueTypeFileName     		= 4;

const TUint KValueTypeEnum				= 5;

const TUint KValueTypeReal				= 6;

const TUint KValueTypeUint64       		= 7;

const TUint KValueTypeInt64        		= 8;

const TUint KValueTypeFlagLast	 		= 0x20000000;	///< Tag this argument as the last one that this command handles. Can only be used with string arguments. Causes the remainder of the command line to be written to the string.

const TUint KValueTypeFlagOptional 		= 0x40000000;	///< Tag this argument being optional. The command should handle the fact that the corresponding variable may not have been initialised (e.g. by calling RCommandArgumentList::IsPresent).

enum TCmdBasePanic

	{

	ENoEnvironment = 0,

	EInvalidCommandOptionType = 1,

	EInvalidCommandArgumentType = 2,

	EIncorrectCommandOptionType1 = 3,

	EIncorrectCommandOptionType2 = 4,

	EIncorrectCommandOptionType3 = 5,

	EIncorrectCommandOptionType4 = 6,

	EIncorrectCommandOptionType5 = 7,

	EIncorrectCommandOptionType6 = 8,

	EIncorrectCommandOptionType7 = 9,

	EIncorrectCommandOptionType8 = 10,

	EIncorrectCommandOptionType9 = 11,

	EIncorrectCommandOptionType10 = 12,

	EIncorrectCommandOptionType11 = 13,

	ERFsNotConnected = 14,

	EAutoAborterAlreadyActive = 15,

	EInvalidArgumentIndex = 16,

	EDuplicateShortOptionName = 17,

	EUnused9 = 18,

	ENoStaticCommand = 19,

	EAlreadyCompleted = 20,

	EInvalidUseOfEnum = 21,

	EUnused10 = 22,

	ECifSubCommandParentNotFound = 23,

	EEnumValueContainsSpace = 24,

	ENonOptionalArgumentFollowsOptionalArgument = 25,

	EArgumentFollowsMultipleArgument = 26,

	EActiveObjectRunLNotOverridden = 27,

	EActiveObjectDoCancelNotOverridden = 28,

	ENotYetComplete = 29,

	EUnused1 = 30,

	EUnused2 = 31,

	EUnused3 = 32,

	EUnused4 = 33,

	EUnused5 = 34,

	EUnused6 = 35,

	EUnused7 = 36,

	EUnused8 = 37,

	EEnvVarNotFound1 = 38,

	EEnvVarNotFound2 = 39,

	EOptionTaggedAsLast = 40,

	ELastArgNotStringType = 41,

	ENoFactory = 42,

	EUnexpectedAsyncCommand = 43,

	EUnused11 = 44,

	ELastArgMultiple = 45,

	EEnumValueOutOfRange = 46,

	EEnumDescriptionMissing = 47,

	EValueTypeAlreadySet = 48,

	EValueDescriptionAlreadySet = 49,

	EEnumValueListAlreadySet = 50,

	EEnumDescriptionListAlreadySet = 51,

	EIncompleteArgumentOrOptionInitialization = 52,

	EENotifyKeypressesSpecifiedWithoutExtensionBeingSet = 53,

	};

class CCommandBase;

class CReaderChangeNotifier;

class CCommandCompleter;

class MLineReader;

class CKeypressWatcher;

class TOverflowTruncate : public TDes16Overflow

	{

public:

	virtual void Overflow(TDes16&) {}

	};

class TOverflowTruncate8 : public TDes8Overflow

	{

public:

	virtual void Overflow(TDes8&) {}

	};

class TOverflowLeave : public TDes16Overflow

	{

public:

	virtual void Overflow(TDes16&) { User::Leave(KErrOverflow); }

	};

class TOverflowLeave8 : public TDes8Overflow

	{

public:

	virtual void Overflow(TDes8&) { User::Leave(KErrOverflow); }

	};

class TFileName2 : public TFileName

	{

public:

	enum TType

		{

		EFile,

		EDirectory

		};

public:

	IMPORT_C TFileName2();

	IMPORT_C TFileName2(TType aType);

	IMPORT_C TFileName2(const TDesC& aName);

	IMPORT_C TFileName2(const TDesC& aName, TType aType);

	IMPORT_C TBool IsAbsolute() const;

	IMPORT_C TBool IsDriveLetter() const;

	IMPORT_C TBool IsDriveRoot() const;

	IMPORT_C TBool IsWild() const;

	IMPORT_C TBool IsFile() const;

	IMPORT_C TBool IsDir() const;

	IMPORT_C TBool HasDriveLetter() const;

	IMPORT_C TBool HasLeadingSlash() const;

	IMPORT_C TBool HasTrailingSlash() const;

	IMPORT_C TPtrC Drive() const;

	IMPORT_C TPtrC Path() const;

	IMPORT_C TPtrC DriveAndPath() const;

	IMPORT_C TPtrC Name() const;

	IMPORT_C TPtrC Ext() const;

	IMPORT_C TPtrC NameAndExt() const;

	IMPORT_C void SetL(const TFileName2& aName);

	IMPORT_C void SetTypeL(TType aType);

	IMPORT_C void SetTypeL(RFs& aFs);

	IMPORT_C void SetDriveL(const TDesC& aDrive);

	IMPORT_C void SetPathL(const TDesC& aPath);

	IMPORT_C void SetNameL(const TDesC& aName);

	IMPORT_C void SetExtL(const TDesC& aExt);

	IMPORT_C void SetNameAndExtL(const TDesC& aNameAndExt);

	IMPORT_C void PrependL(const TFileName2& aName);

	IMPORT_C void AppendComponentL(const TFileName2& aName);

	IMPORT_C void AppendComponentL(const TDesC& aPathComponent, TType aPathComponentType);

	IMPORT_C void AppendComponentL(const TEntry& aEntry);

	IMPORT_C void SplitL(RArray<TFileName2>& aOutput);

	IMPORT_C void UnsplitL(const RArray<TFileName2>& aInput);

	IMPORT_C void MakeAbsoluteL(const TFileName2& aAbsoluteTo);

	IMPORT_C void MakeAbsoluteL(RFs& aFs); // Make absolute relative to aFs's session path

	IMPORT_C TBool Exists(RFs& aFs) const;

	IMPORT_C TBool IsReadOnlyL(RFs& aFs) const;

	IMPORT_C TBool IsHiddenL(RFs& aFs) const;

	IMPORT_C TBool IsSystemL(RFs& aFs) const;

	IMPORT_C TBool IsDirL(RFs& aFs) const;

	IMPORT_C TBool IsArchiveL(RFs& aFs) const;

	IMPORT_C void SetIsDirectoryL(); // Ensure the descriptor ends in a slash

	IMPORT_C TInt FindFile(RFs& aFs);

	IMPORT_C void FindFileL(RFs& aFs);

	IMPORT_C void Normalize(RFs& aFs);

private:

	void CheckSpaceL(TInt aLengthToAdd) const;

private:

	TType iType;

	};

enum TAlignment

	{

	EUnaligned,

	EColumnAlignedLeft,

	EColumnAlignedRight

	};

enum TTabMode

	{

	EWrapLastColumn,

	ETruncateLongestColumn,

	EIgnoreAvailableWidth,

	};

NONSHARABLE_CLASS(CTextBuffer) : public CActive

	{

public:

	IMPORT_C static CTextBuffer* NewL(TInt aExpandSize);

	IMPORT_C static CTextBuffer* NewLC(TInt aExpandSize);

	IMPORT_C ~CTextBuffer();

	IMPORT_C virtual void Zero();

	IMPORT_C virtual void Reset();

	IMPORT_C virtual void ResetText();

	IMPORT_C void SetAttributesL(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor = ConsoleAttributes::EUnchanged, ConsoleAttributes::TColor aBackgroundColor = ConsoleAttributes::EUnchanged);

	IMPORT_C void SetAttributesL(const ConsoleAttributes::TAttributes& aAttributes);

	IMPORT_C void GetCurrentAttributes(TUint& aAttributes, ConsoleAttributes::TColor& aForegroundColor, ConsoleAttributes::TColor& aBackgroundColor) const;

	IMPORT_C void GetAttributes(TInt aPos, TUint& aAttributes, ConsoleAttributes::TColor& aForegroundColor, ConsoleAttributes::TColor& aBackgroundColor) const;

	IMPORT_C void AppendL(const TChar& aChar);

	IMPORT_C void AppendL(const TDesC16& aText);

	IMPORT_C void AppendL(const TDesC8& aText);

	IMPORT_C void AppendL(const CTextBuffer& aText);

	IMPORT_C void AppendL(const CTextBuffer& aText, TInt aPosition);

	IMPORT_C void AppendL(const CTextBuffer& aText, TInt aPosition, TInt aLength);

	IMPORT_C void AppendFormatL(TRefByValue<const TDesC> aFmt, ...);

	IMPORT_C void AppendFormatL(TRefByValue<const TDesC8> aFmt, ...);

	IMPORT_C void AppendFormatListL(const TDesC16& aFmt, VA_LIST& aList);

	IMPORT_C void AppendFormatListL(const TDesC8& aFmt, VA_LIST& aList);

	IMPORT_C void AppendHumanReadableSizeL(TInt aSize);

	IMPORT_C void AppendHumanReadableSizeL(TInt64 aSize);

	IMPORT_C void AppendHumanReadableSizeL(TInt aSize, TAlignment aAlignment);

	IMPORT_C void AppendHumanReadableSizeL(TInt64 aSize, TAlignment aAlignment);

	IMPORT_C void AppendSpacesL(TInt aCount);

	IMPORT_C void Delete(TInt aPos, TInt aLength);

	IMPORT_C TInt Length() const;

	IMPORT_C const TDesC& Descriptor() const;

	IMPORT_C const TDesC& Descriptor(TInt aPos, TInt aLength) const;

	IMPORT_C TPtrC8 Collapse();

	IMPORT_C TInt Write(RIoWriteHandle& aWriteHandle) const;

	IMPORT_C void Write(RIoWriteHandle& aWriteHandle, TRequestStatus& aStatus) const;

	IMPORT_C TInt Write(RIoWriteHandle& aWriteHandle, TInt aPosition, TInt aLength) const;

	IMPORT_C void Write(RIoWriteHandle& aWriteHandle, TInt aPosition, TInt aLength, TRequestStatus& aStatus) const;

protected:

	CTextBuffer();

	void ConstructL(TInt aExpandSize);

private:

	void NextBlock(TInt& aBlockIndex, const TDesC*& aText, TUint& aAttributes, ConsoleAttributes::TColor& aForegroundColor, ConsoleAttributes::TColor& aBackgroundColor) const;

	void AsyncWriteNextBlock() const;

private: // From CActive.

	virtual void RunL();

	virtual void DoCancel();

private:

	class TAttributes

		{

	public:

		TAttributes(TInt aPosition, TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor);

		TBool Matches(TUint aAttributes, ConsoleAttributes::TColor aForegroundColor, ConsoleAttributes::TColor aBackgroundColor) const;

	public:

		TInt iPosition;

		ConsoleAttributes::TAttributes iAttributes;

		};

private:

	CBufBase* iBuf;

	mutable TPtrC iPtr;

	HBufC* iScratchBuf;

	HBufC8* iScratchBuf8;

	RArray<TAttributes> iAttributes;

	mutable RIoConsoleWriteHandle iConsoleWriteHandle; // Not owned.

	mutable TInt iAsyncBlockIndex;

	mutable TInt iAsyncWritePos;

	mutable TInt iAsyncWriteStartPos;

	mutable TInt iAsyncWriteLength;

	mutable TPtrC iAsyncWritePtr;

	mutable TRequestStatus* iWriteStatus;

	};

NONSHARABLE_CLASS(CTextFormatter) : public CTextBuffer

	{

public:

	IMPORT_C static CTextFormatter* NewL(TInt aAvailableWidth);

	IMPORT_C static CTextFormatter* NewLC(TInt aAvailableWidth);

	IMPORT_C static CTextFormatter* NewL(RIoConsoleWriteHandle& aConsoleWriteHandle);

	IMPORT_C static CTextFormatter* NewLC(RIoConsoleWriteHandle& aConsoleWriteHandle);

	IMPORT_C ~CTextFormatter();

	IMPORT_C virtual void Zero();

	IMPORT_C virtual void Reset();

	IMPORT_C virtual void ResetText();

	IMPORT_C void WrapL(TInt aIndent, const TDesC& aText);

	IMPORT_C void WrapL(TInt aStartPosition, TInt aIndent, const TDesC& aText);

	IMPORT_C void TabulateL(TInt aIndent, TInt aGap, const TDesC& aText);

	IMPORT_C void TabulateL(TInt aIndent, TInt aGap, const TDesC& aText, TTabMode aMode);

	IMPORT_C void ColumnizeL(TInt aIndent, TInt aGap, const TDesC& aText);

	IMPORT_C void ColumnizeL(TInt aIndent, TInt aGap, const TArray<TPtrC>& aItems);

	IMPORT_C void AppendPodL(const TDesC& aPod);

	IMPORT_C TInt Write();

private:

	CTextFormatter(TInt aAvailableWidth);

	void ConstructL();

	void DoAppendPodL(const TDesC& aPod);

	void DecodeInteriorPodSequencesL(const TDesC& aPod, CTextBuffer& aBuffer) const;

	TBool NextColumn(TLex& aLex, TPtrC& aPtr) const;

	TBool NextLine(TLex& aLex, TPtrC& aPtr) const;

	TInt ActualLength(const TDesC& aPod) const;

private:

	TInt iAvailableWidth;

	RIoConsoleWriteHandle* iWriteHandle;

	TBool iAttributesSupported;

	};

NONSHARABLE_CLASS(CEnvironment) : public CBase

	{

public:

	IMPORT_C static CEnvironment* NewL();

	IMPORT_C static CEnvironment* NewL(const CEnvironment& aEnv);

	IMPORT_C ~CEnvironment();

	IMPORT_C void SetL(const TDesC& aKey, TInt aValue);

	IMPORT_C void SetL(const TDesC& aKey, const TDesC& aValue);

	IMPORT_C TInt GetAsInt(const TDesC& aKey) const;

	IMPORT_C TInt GetAsIntL(const TDesC& aKey) const;

	IMPORT_C const TDesC& GetAsDes(const TDesC& aKey) const;

	IMPORT_C const TDesC& GetAsDesL(const TDesC& aKey) const;

	IMPORT_C TInt Remove(const TDesC& aKey);

	IMPORT_C void RemoveL(const TDesC& aKey);

	IMPORT_C void RemoveAll(); // Doesn't remove anything in parent env

	IMPORT_C void InternalizeL(const TDesC8& aDes);

	IMPORT_C HBufC8* ExternalizeLC() const;

	IMPORT_C TBool IsDefined(const TDesC& aKey) const;

	IMPORT_C TBool IsInt(const TDesC& aKey) const;

	IMPORT_C TBool IsDes(const TDesC& aKey) const;

	IMPORT_C TInt Count() const;

	IMPORT_C void GetKeysL(RPointerArray<HBufC>& aResult) const;

	IMPORT_C void SetPwdL(const TDesC& aPwd);

	IMPORT_C const TDesC& Pwd() const;

	IMPORT_C TChar EscapeChar() const;

	IMPORT_C void SetLocalL(const TDesC& aKey);

	IMPORT_C CEnvironment* CreateSharedEnvironmentL();

private:

	CEnvironment();

	CEnvironment(CEnvironment* aParentEnv);

	void ConstructL();

	void WaitLC() const;

	static void Signal(TAny* aSelf);

	void Lock() const;

	void Unlock() const;

	void CopyL(const CEnvironment& aEnv);

	HBufC* Get(const TDesC& aKey) const;

	HBufC* GetL(const TDesC& aKey) const;

private:

	TUint32 iVarsImpl[14];

	mutable RMutex iLock;

	CEnvironment* iParentEnv;

	};

class MCommandBaseObserver

	{

public:

	virtual void HandleCommandComplete(CCommandBase& aCommand, TInt aError) = 0;

	};

class TEnum

	{

public:

	IMPORT_C TEnum();

	IMPORT_C TEnum(const TDesC& aEnumValueList);

	IMPORT_C TEnum(const TDesC& aEnumValueList, const TDesC& aEnumDescriptionList);

	IMPORT_C TInt Parse(const TDesC& aString, TInt& aValue);

	IMPORT_C TInt ParseL(const TDesC& aString);

	IMPORT_C const TDesC& ValueList() const;

	IMPORT_C const TDesC& DescriptionList() const;

	IMPORT_C void AppendValuesL(CTextBuffer& aBuf) const;

	IMPORT_C const TPtrC GetString(TInt aIndex) const;

	IMPORT_C void SetValueList(const TDesC& aValueList);

	IMPORT_C void SetDescriptionList(const TDesC& aDescriptionList);

	IMPORT_C void operator=(const TEnum& aEnum);

private:

	void ValidateValues() const;

	TInt GetMatches(const TDesC& aString, RArray<TInt>& aMatches, TInt& aExactMatch);

private:

	TPtrC iEnumValueList;

	TPtrC iEnumDescriptionList;

	};

class TValue

	{

public:

	IMPORT_C const TDesC& Name() const;

	IMPORT_C TUint Type() const;

	IMPORT_C TBool AcceptsMultiple() const;

	IMPORT_C const TDesC& EnvVar() const;

	IMPORT_C void* ValuePtr() const;

	IMPORT_C const TDesC& EnumValueList() const;

	TValue(TUint aValueType, void* aValuePointer, const TDesC& aName);

	TValue(TUint aValueType, void* aValuePointer, const TDesC& aName, const TDesC& aDescription, const TDesC& aEnvVar = KNullDesC);

	TValue(TUint aValueType, const TDesC& aEnumValueList, const TDesC& aEnumDescriptionList, void* aValuePointer, const TDesC& aName, const TDesC& aDescription, const TDesC& aEnvVar = KNullDesC);

	TUint ValueType() const;

	void SetValue();

	void SetValueL(TInt aInt);

	void SetValueL(TInt64 aInt);

	void SetValueL(TUint aUint);

	void SetValueL(TUint64 aUint);

	void SetValueL(TReal64 aReal);

	void SetValueL(HBufC* aString);

	void SetValueL(const TFileName2& aFileName, RFs& aFs);

	void SetEnumValues(const TEnum& aEnum);

	TBool IsSet() const;

	const TDesC& EnumDescriptionList() const;

	const TDesC& Description() const;

	TPtrC AsString() const;

	void AppendEnumValuesL(CTextBuffer& aBuf) const;

	void Combine(const TValue& aValue);

protected:

	TUint iValueType;

	void* iValue;

	TBool iIsSet;

	TPtrC iEnvVar;

	TEnum iEnum;

	const TPtrC iName;

	TPtrC iDescription;

	};

class TCommandOption : public TValue

	{

public:

	TCommandOption(TUint aValueType, void* aValuePointer, const TDesC& aLongName);

	TCommandOption(TUint aValueType, void* aValuePointer, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, const TDesC& aEnvVar = KNullDesC);

	TCommandOption(void* aValuePointer, TUint aValueType, const TDesC& aCommaSeparatedValueList, const TDesC& aCommaSeparatedDescriptionList, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, const TDesC& aEnvVar = KNullDesC);

	TChar ShortName() const;

	void Combine(const TCommandOption& aOption);

private:

	TChar iShortName;

	};

class RCommandOptionList

	{

public:

	// Use these APIs to only partially declare options in C++ code, and to have the remaining details (e.g. documentation) read from a Command Info File (CIF).

	IMPORT_C void AppendBoolL(TBool& aBool, const TDesC& aLongName);

	IMPORT_C void AppendBoolL(RArray<TBool>& aBools, const TDesC& aLongName);

	IMPORT_C void AppendIntL(TInt& aInt, const TDesC& aLongName);

	IMPORT_C void AppendIntL(RArray<TInt>& aInts, const TDesC& aLongName);

	IMPORT_C void AppendIntL(TInt64& aInt, const TDesC& aLongName);

	IMPORT_C void AppendIntL(RArray<TInt64>& aInts, const TDesC& aLongName);

	IMPORT_C void AppendUintL(TUint& aUint, const TDesC& aLongName);

	IMPORT_C void AppendUintL(RArray<TUint>& aUints, const TDesC& aLongName);

	IMPORT_C void AppendUintL(TUint64& aUint, const TDesC& aLongName);

	IMPORT_C void AppendUintL(RArray<TUint64>& aUints, const TDesC& aLongName);

	IMPORT_C void AppendRealL(TReal64& aReal, const TDesC& aLongName);

	IMPORT_C void AppendRealL(RArray<TReal64>& aReals, const TDesC& aLongName);

	IMPORT_C void AppendStringL(HBufC*& aBuf, const TDesC& aLongName);

	IMPORT_C void AppendStringL(RPointerArray<HBufC>& aBufs, const TDesC& aLongName);

	IMPORT_C void AppendFileNameL(TFileName2& aFileName, const TDesC& aLongName);

	IMPORT_C void AppendFileNameL(RArray<TFileName2>& aFileNames, const TDesC& aLongName);

	IMPORT_C void AppendEnumL(TInt& aEnum, const TDesC& aLongName);

	IMPORT_C void AppendEnumL(TInt& aEnum, const TDesC& aLongName, const TDesC& aCommaSeparatedValueList);

	IMPORT_C void AppendEnumL(RArray<TInt>& aEnum, const TDesC& aLongName); // Be sure to pass an actual RArray<TInt>& here, not an RArray<TSomeEnum>&. Internally, CCommandBase casts whatever you pass in to an RArray<TInt> and this is a specialized template withe a different memory layout to the general version.

	IMPORT_C void AppendEnumL(RArray<TInt>& aEnum, const TDesC& aLongName, const TDesC& aCommaSeparatedValueList); // Be sure to pass an actual RArray<TInt>& here, not an RArray<TSomeEnum>&. Internally, CCommandBase casts whatever you pass in to an RArray<TInt> and this is a specialized template withe a different memory layout to the general version.

	// Use these APIs to fully declare options in C++ code.

	IMPORT_C void AppendBoolL(TBool& aBool, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendBoolL(RArray<TBool>& aBools, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendIntL(TInt& aInt, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendIntL(RArray<TInt>& aInts, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendIntL(TInt64& aInt, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendIntL(RArray<TInt64>& aInts, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendUintL(TUint& aUint, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendUintL(RArray<TUint>& aUints, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendUintL(TUint64& aUint, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendUintL(RArray<TUint64>& aUints, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendRealL(TReal64& aReal, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendRealL(RArray<TReal64>& aReals, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendStringL(HBufC*& aBuf, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendStringL(RPointerArray<HBufC>& aBufs, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendFileNameL(TFileName2& aFileName, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendFileNameL(RArray<TFileName2>& aFileNames, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendEnumL(TInt& aEnum, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, const TDesC& aCommaSeparatedValueList, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendEnumL(TInt& aEnum, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, const TDesC& aCommaSeparatedValueList, const TDesC& aCommaSeparatedDescriptionList, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC);

	IMPORT_C void AppendEnumL(RArray<TInt>& aEnum, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, const TDesC& aCommaSeparatedValueList, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC); // Be sure to pass an actual RArray<TInt>& here, not an RArray<TSomeEnum>&. Internally, CCommandBase casts whatever you pass in to an RArray<TInt> and this is a specialized template withe a different memory layout to the general version.

	IMPORT_C void AppendEnumL(RArray<TInt>& aEnum, TChar aShortName, const TDesC& aLongName, const TDesC& aDescription, const TDesC& aCommaSeparatedValueList, const TDesC& aCommaSeparatedDescriptionList, TUint aFlags = 0, const TDesC& aEnvVar = KNullDesC); // Be sure to pass an actual RArray<TInt>& here, not an RArray<TSomeEnum>&. Internally, CCommandBase casts whatever you pass in to an RArray<TInt> and this is a specialized template withe a different memory layout to the general version.

	IMPORT_C TBool IsPresent(void* aValuePointer) const;

	IMPORT_C TPtrC AsString(void* aValuePointer) const;

	void Close();

	IMPORT_C TInt Count() const;

	IMPORT_C TCommandOption& operator[](TInt aIndex);

	IMPORT_C const TCommandOption& operator[](TInt aIndex) const;

	TInt FindShort(TChar aShortName) const;

	TInt Find(const TDesC& aLongName) const;

private:

	void Validate(const TCommandOption& aOption);

private:

	RArray<TCommandOption> iOptions;

	};

class TCommandArgument : public TValue

	{

public:

	TCommandArgument(TUint aValueType, void* aValuePointer, const TDesC& aName);

	TCommandArgument(TUint aValueType, void* aValuePointer, const TDesC& aName, const TDesC& aDescription, const TDesC& aEnvVar = KNullDesC);

	TCommandArgument(void* aValuePointer, TUint aValueType, const TDesC& aName, const TDesC& aDescription, const TDesC& aCommaSeparatedValueList, const TDesC& aCommaSeparatedDescriptionList, const TDesC& aEnvVar = KNullDesC);

	TBool IsOptional() const;

	TBool IsLast() const;

	};

class RCommandArgumentList

	{

public:

	// Use these APIs to only partially declare arguments in C++ code, and to have the remaining details (e.g. documentation) read from a Command Info File (CIF).

	IMPORT_C void AppendIntL(TInt& aInt, const TDesC& aName);

	IMPORT_C void AppendIntL(RArray<TInt>& aInts, const TDesC& aName);

	IMPORT_C void AppendIntL(TInt64& aInt, const TDesC& aName);

	IMPORT_C void AppendIntL(RArray<TInt64>& aInts, const TDesC& aName);

	IMPORT_C void AppendUintL(TUint& aUint, const TDesC& aName);

	IMPORT_C void AppendUintL(RArray<TUint>& aUints, const TDesC& aName);

	IMPORT_C void AppendUintL(TUint64& aUint, const TDesC& aName);

	IMPORT_C void AppendUintL(RArray<TUint64>& aUints, const TDesC& aName);