// env.cpp

// 

// Copyright (c) 2006 - 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 "ioutils.h"

#include "command_base.h"

#include <fshell/stringhash.h>

#include <fshell/ltkutils.h>

#include <fshell/descriptorutils.h>

using namespace IoUtils;

using LtkUtils::RStringHash;

using LtkUtils::TStringHashIter;

#define iVars (*reinterpret_cast<RStringHash<HBufC*>*>(iVarsImpl))

#define ConstVarsFor(x) (*reinterpret_cast<const RStringHash<HBufC*>*>((x)->iVarsImpl))

#define iConstVars ConstVarsFor(this)

//

// Constants.

//

_LIT(KEnvPwd, "PWD");

_LIT(KDefaultPwd, "c:\\");

_LIT(KChildError, "?");

_LIT(KEnvEscapeChar, "ESCAPE");

//

// CEnvironment.

//

EXPORT_C CEnvironment* CEnvironment::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	self->SetPwdL(KDefaultPwd);

	self->SetL(KChildError, KErrNone);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CEnvironment* CEnvironment::NewL(const CEnvironment& aEnv)

	{

	CEnvironment* self = CEnvironment::NewL();

	CleanupStack::PushL(self);

	self->CopyL(aEnv);

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CEnvironment* CEnvironment::CreateSharedEnvironmentL()

	{

	CEnvironment* newenv = new(ELeave) CEnvironment(this);

	CleanupStack::PushL(newenv);

	newenv->ConstructL();

	CleanupStack::Pop(newenv);

	return newenv;

	}

EXPORT_C CEnvironment::~CEnvironment()

	{

	RemoveAll();

	iLock.Close();

	}

EXPORT_C void CEnvironment::RemoveAll()

	{

	// Note this doesn't affect iParentEnv

	if (iLock.Handle())

		{

		iLock.Wait();

		TStringHashIter<HBufC*> iter(iVars);

		while (iter.NextValue() != NULL)

			{

			delete *iter.CurrentValue();

			}

		iVars.Close();

		iLock.Signal();

		}

	}

CEnvironment::CEnvironment()

	{

	__ASSERT_COMPILE(sizeof(iVarsImpl) == sizeof(RStringHash<HBufC*>));

	// Have to placement new iVars because we hide the type

	new(iVarsImpl) RStringHash<HBufC*>;

	}

CEnvironment::CEnvironment(CEnvironment* aParentEnv)

	: iParentEnv(aParentEnv)

	{

	new(iVarsImpl) RStringHash<HBufC*>;

	}

void CEnvironment::ConstructL()

	{

	User::LeaveIfError(iLock.CreateLocal());

	}

void CEnvironment::Lock() const

	{

	iLock.Wait();

	if (iParentEnv) iParentEnv->iLock.Wait();

	}

void CEnvironment::Unlock() const

	{

	if (iParentEnv) iParentEnv->iLock.Signal();

	iLock.Signal();

	}

void CEnvironment::WaitLC() const

	{

	Lock();

	CleanupStack::PushL(TCleanupItem(Signal, const_cast<CEnvironment*>(this)));

	}

void CEnvironment::Signal(TAny* aSelf)

	{

	static_cast<CEnvironment*>(aSelf)->Unlock();

	}

EXPORT_C void CEnvironment::SetL(const TDesC& aKey, TInt aValue)

	{

	TBuf<32> buf;

	buf.AppendNum(aValue);

	SetL(aKey, buf);

	}

EXPORT_C void CEnvironment::SetL(const TDesC& aKey, const TDesC& aValue)

	{

	WaitLC();

	HBufC** valPtr = iVars.Find(aKey);

	if (valPtr == NULL && iParentEnv)

		{

		// If we don't have it, and we have a parent env, we should pass the request through to it.

		iParentEnv->SetL(aKey, aValue);

		}

	else if (valPtr)

		{

		// The key is present in the hash.

		HBufC* currentValue = *valPtr;

		if (currentValue && (currentValue->Des().MaxLength() >= aValue.Length()))

			{

			// If the existing HBufC is big enough, simply copy.

			// Note, currentValue will be NULL if this is the first time a 'local' variable is being set.

			currentValue->Des().Copy(aValue);

			}

		else

			{

			// Otherwise allocate a new HBufC.

			*valPtr = aValue.AllocL();

			delete currentValue;

			}

		}

	else

		{

		// New key.

		HBufC* newVal = aValue.AllocLC();

		iVars.InsertL(aKey, newVal);

		CleanupStack::Pop(newVal);

		}

	CleanupStack::PopAndDestroy(); // Release lock

	}

HBufC* CEnvironment::Get(const TDesC& aKey) const

	{

	HBufC*const* valPtr = iConstVars.Find(aKey);

	if (valPtr == NULL && iParentEnv)

		{

		return iParentEnv->Get(aKey);

		}

	else if (valPtr)

		{

		return *valPtr;

		}

	else

		{

		return NULL;

		}

	}

HBufC* CEnvironment::GetL(const TDesC& aKey) const

	{

	HBufC* var = Get(aKey);

	if (var == NULL) User::Leave(KErrNotFound);

	return var;

	}

EXPORT_C TInt CEnvironment::GetAsInt(const TDesC& aKey) const

	{

	Lock();

	HBufC* var = Get(aKey);

	__ASSERT_ALWAYS(var, Panic(EEnvVarNotFound1));

	TLex lex(*var);

	TInt result = 0;

	lex.Val(result);

	Unlock();

	return result;

	}

EXPORT_C TInt CEnvironment::GetAsIntL(const TDesC& aKey) const

	{

	WaitLC();

	HBufC* var = GetL(aKey);

	TLex lex(*var);

	TInt ret = 0;

	lex.Val(ret);

	CleanupStack::PopAndDestroy(); // Release lock

	return ret;

	}

EXPORT_C const TDesC& CEnvironment::GetAsDes(const TDesC& aKey) const

	{

	Lock();

	HBufC* var = Get(aKey);

	__ASSERT_ALWAYS(var, Panic(EEnvVarNotFound2));

	Unlock();

	return *var;

	}

EXPORT_C const TDesC& CEnvironment::GetAsDesL(const TDesC& aKey) const

	{

	WaitLC();

	const TDesC& des = *GetL(aKey);

	CleanupStack::PopAndDestroy(); // Release lock

	return des;

	}

EXPORT_C TInt CEnvironment::Remove(const TDesC& aKey)

	{

	Lock();

	HBufC** valPtr = iVars.Find(aKey);

	TInt ret = KErrNone;

	if (valPtr == NULL && iParentEnv)

		{

		// Not in ours, look at parent env

		ret = iParentEnv->Remove(aKey);

		}

	else if (valPtr && *valPtr)

		{

		// In ours

		delete *valPtr;

		if (iParentEnv)

			{

			// Need to remember we've removed it

			*valPtr = NULL;

			}

		else

			{

			iVars.Remove(aKey);

			}

		}

	else

		{

		// Not in ours and no parent env, or in ours and null

		ret = KErrNotFound;

		}

	Unlock();

	return ret;

	}

EXPORT_C void CEnvironment::RemoveL(const TDesC& aKey)

	{

	User::LeaveIfError(Remove(aKey));

	}

void CEnvironment::CopyL(const CEnvironment& aEnv)

	{

	RemoveAll();

	WaitLC();

	aEnv.WaitLC();

	RPointerArray<HBufC> keys;

	LtkUtils::CleanupResetAndDestroyPushL(keys);

	aEnv.GetKeysL(keys);

	for (TInt i = 0; i < keys.Count(); i++)

		{

		SetL(*keys[i], aEnv.GetAsDes(*keys[i]));

		}

	CleanupStack::PopAndDestroy(3); // keys, WaitLC x 2.

	}

class TDesRead

	{

public:

	TDesRead(const TDesC8& aDes);

	TInt32 ReadInt32();

	TPtrC ReadDes();

private:

	const TDesC8& iDes;

	TInt iPos;

	};

class TDesWrite

	{

public:

	TDesWrite(LtkUtils::RLtkBuf8& aDes);

	void WriteL(TInt32 aInt);

	void WriteL(const TDesC& aDes);

private:

	LtkUtils::RLtkBuf8& iDes;

	};

EXPORT_C void CEnvironment::InternalizeL(const TDesC8& aDes)

	{

	WaitLC();

	TDesRead desRead(aDes);

	TInt varCount = desRead.ReadInt32();

	while (varCount--)

		{

		TPtrC key = desRead.ReadDes();

		TPtrC val = desRead.ReadDes();

		SetL(key, val);

		}

	CleanupStack::PopAndDestroy(); // Release lock

	}

EXPORT_C HBufC8* CEnvironment::ExternalizeLC() const

	{

	WaitLC();

	LtkUtils::RLtkBuf8 buf;

	CleanupClosePushL(buf);

	TDesWrite desWrite(buf);

	RPointerArray<HBufC> keys;

	LtkUtils::CleanupResetAndDestroyPushL(keys);

	GetKeysL(keys);

	desWrite.WriteL(keys.Count());

	for (TInt i = 0; i < keys.Count(); i++)

		{

		desWrite.WriteL(*keys[i]);

		desWrite.WriteL(GetAsDes(*keys[i]));

		}

	CleanupStack::PopAndDestroy(&keys);

	CleanupStack::Pop(&buf);

	CleanupStack::PopAndDestroy(); // Release lock

	HBufC8* res = buf.ToHBuf();

	CleanupStack::PushL(res);

	return res;

	}

TInt StringCompare(const HBufC& aLeft, const HBufC& aRight)

	{

	return aLeft.Compare(aRight);

	}

EXPORT_C void CEnvironment::GetKeysL(RPointerArray<HBufC>& aResult) const

	{

	WaitLC();

	aResult.ResetAndDestroy();

	TStringHashIter<HBufC*> iter(iConstVars);

	while (iter.NextValue() != NULL)

		{

		if (*iter.CurrentValue() != NULL)

			{

			HBufC* key = iter.CurrentKey()->AllocLC();

			aResult.AppendL(key);

			CleanupStack::Pop(key);

			}

		}

	if (iParentEnv)

		{

		RPointerArray<HBufC> parentKeys;

		LtkUtils::CleanupResetAndDestroyPushL(parentKeys);

		iParentEnv->GetKeysL(parentKeys);

		for (TInt i = parentKeys.Count()-1; i >= 0; i--)

			{

			HBufC* key = parentKeys[i];

			if (iConstVars.Find(*key) == NULL)

				{

				// Only add stuff in parent that isn't also in ours

				aResult.AppendL(key);

				parentKeys.Remove(i);

				}

			}

		CleanupStack::PopAndDestroy(&parentKeys);

		}

	// Make sure the resulting array is alphabetic, as RStringHash doesn't guarantee that (unlike RVarSet)

	aResult.Sort(TLinearOrder<HBufC>(&StringCompare));

	CleanupStack::PopAndDestroy(); // Release lock

	}

EXPORT_C TBool CEnvironment::IsDefined(const TDesC& aKey) const

	{

	iLock.Wait();

	TBool ret = (Get(aKey) != NULL);

	iLock.Signal();

	return ret;

	}

EXPORT_C TBool CEnvironment::IsInt(const TDesC& aKey) const

	{

	iLock.Wait();

	HBufC* val = Get(aKey);

	iLock.Signal();

	if (val == NULL) return EFalse;

	TLex lex(*val);

	TBool atLeastOneDigit(EFalse);

	while (!lex.Eos())

		{

		if (lex.Get().IsDigit())

			{

			atLeastOneDigit = ETrue;

			}

		else

			{

			return EFalse;

			}

		}

	return atLeastOneDigit;

	}

EXPORT_C TBool CEnvironment::IsDes(const TDesC& aKey) const

	{

	return IsDefined(aKey);

	}

EXPORT_C TInt CEnvironment::Count() const

	{

	iLock.Wait();

	TInt ret = iConstVars.Count();

	iLock.Signal();

	return ret;

	}

EXPORT_C void CEnvironment::SetPwdL(const TDesC& aPwd)

	{

	SetL(KEnvPwd, aPwd);

	}

EXPORT_C const TDesC& CEnvironment::Pwd() const

	{

	return GetAsDes(KEnvPwd);

	}

EXPORT_C TChar CEnvironment::EscapeChar() const

	{

	iLock.Wait();

	HBufC* var = Get(KEnvEscapeChar);

	TUint16 escape = '^';

	if (var)

		{

		escape = (*var)[0];

		}

	iLock.Signal();

	return TChar(escape);

	}

// Declare aKey so that changes aren't reflected in the parent environment

EXPORT_C void CEnvironment::SetLocalL(const TDesC& aKey)

	{

	if (iParentEnv == NULL)

		{

		// Nothing needed if there is no parent, then everything is effectively local anyway

		return;

		}

	WaitLC();

	HBufC** currentValPtr = iVars.Find(aKey);

	if (currentValPtr)

		{

		// It's already local

		CleanupStack::PopAndDestroy(); // Release lock

		return;

		}

	// Local vals start out undefined, regardless of what the parent's value is

	iVars.InsertL(aKey, NULL);

	CleanupStack::PopAndDestroy(); // Release lock

	}

//

// TDesRead.

//

TDesRead::TDesRead(const TDesC8& aDes)

	: iDes(aDes), iPos(0)

	{

	}

TInt32 TDesRead::ReadInt32()

	{

	TInt32 int32;

	TPckg<TInt32> intPckg(int32);

	intPckg.Copy(iDes.Mid(iPos, sizeof(TInt32)));

	iPos += sizeof(TInt32);

	return int32;

	}

TPtrC TDesRead::ReadDes()

	{

	const TInt length = ReadInt32();

	const TInt size = length * 2;

	if (iPos & 1) iPos++; // 16-bit descriptors are 2-byte aligned

	TPtrC8 ptr8 = iDes.Mid(iPos, size);

	TPtrC result((const TUint16*)ptr8.Ptr(), length);

	iPos += size;

	return result;

	}

//

// TDesWrite.

//