// Copyright (c) 2006-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:
// Data structures for generic access point information
// 
//

/**
 @file
 @publishedPartner
 @released
*/



#ifndef _ES_ACCESSPOINTSTATUS_H_
#define _ES_ACCESSPOINTSTATUS_H_


namespace ConnectionServ
{

// Type TAccessPointStatus (containing TAccessPointFlagValue instances) represents the status flags for an access point.
// As well as the value of the flag True/False, 
//  they include EUnknown, the case where the value isn't (yet) known / wasn't retrieved.

struct TAccessPointStatusFilter;

enum TAccessPointFlagValue
	{
	EAccessPointFlagUnknown = 0,
	EAccessPointFlagTrue = 1,
	EAccessPointFlagFalse = 2
	};

struct TAccessPointStatus
	{
	union
		{
		struct
			{
			TUint iConfigured:2;
			TUint iRestricted:2;
			TUint iAvailable:2;
			TUint iStarted:2;
			TUint iActive:2;
			} iS;
		TInt64 iAsInt;
		} iU;
	
	TAccessPointStatus(TInt64 aI)
		{
		iU.iAsInt = aI;
		}

	TAccessPointStatus()
		{
		iU.iAsInt = TInt64(0);
		}

	TInt64 AsInt64() const { return iU.iAsInt; }

	void Configured(TAccessPointFlagValue aVal) {iU.iS.iConfigured = aVal;}
	TAccessPointFlagValue Configured() const {return static_cast<TAccessPointFlagValue>(iU.iS.iConfigured);}

	void Restricted(TAccessPointFlagValue aVal) {iU.iS.iRestricted = aVal;}
	TAccessPointFlagValue Restricted() const {return static_cast<TAccessPointFlagValue>(iU.iS.iRestricted);}

	void Available(TAccessPointFlagValue aVal) {iU.iS.iAvailable = aVal;}
	TAccessPointFlagValue Available() const {return static_cast<TAccessPointFlagValue>(iU.iS.iAvailable);}

	void Started(TAccessPointFlagValue aVal) {iU.iS.iStarted = aVal;}
	TAccessPointFlagValue Started() const {return static_cast<TAccessPointFlagValue>(iU.iS.iStarted);}

	void Active(TAccessPointFlagValue aVal) {iU.iS.iActive = aVal;}
	TAccessPointFlagValue Active() const {return static_cast<TAccessPointFlagValue>(iU.iS.iActive);}

	void UpdateWith(const TAccessPointStatus& aSrc)
		{
		// Fields:	CRAS

		// Initial:	CR??
		// +
		// New:		C?a?
		// =
		// Result	CRa?

		// +
		// New:		C?A?
		// =
		// Result:	CRA?

		TAccessPointFlagValue value = static_cast<TAccessPointFlagValue>(iU.iS.iConfigured);
		TAccessPointStatus::PickUpIfSrcKnown( value, aSrc.Configured() );
		iU.iS.iConfigured = value;

		value = static_cast<TAccessPointFlagValue>(iU.iS.iRestricted);
		TAccessPointStatus::PickUpIfSrcKnown( value, aSrc.Restricted() );
		iU.iS.iRestricted = value;

		value = static_cast<TAccessPointFlagValue>(iU.iS.iAvailable);
		TAccessPointStatus::PickUpIfSrcKnown( value, aSrc.Available() );
		iU.iS.iAvailable = value;

		value = static_cast<TAccessPointFlagValue>(iU.iS.iStarted);
		TAccessPointStatus::PickUpIfSrcKnown( value, aSrc.Started() );
		iU.iS.iStarted = value;

		value = static_cast<TAccessPointFlagValue>(iU.iS.iActive);
		TAccessPointStatus::PickUpIfSrcKnown( value, aSrc.Active() );
		iU.iS.iActive = value;
		}

	static void PickUpIfSrcKnown(TAccessPointFlagValue& aDest, const TAccessPointFlagValue aSrc )
		{
		if(aSrc != EAccessPointFlagUnknown)
			{
			aDest = aSrc;
			}
		}

	inline void CopyFieldsRequiredByQueryFrom(const TAccessPointStatusFilter& aFilter,const TAccessPointStatus& aSource);

	static TText FlagValueAsChar(TAccessPointFlagValue aVal)
		{
		switch(aVal)
			{
			case EAccessPointFlagFalse: return 'N';
			case EAccessPointFlagTrue: return 'Y';
			}
		
		return '?';
		}
	};

// Type TAccessPointStatusFilter (containing TAccessPointFlagFilterValue instances) represents a query against the above type.
// As well as the value of the flag True/False, meaning "(find the value and) match true/false"
//  they include EAny, meaning "(retrieve the value and) match either value"
//    ... and .. EIgnore, meaning "don't retrieve the value"
// This is of use for fields such as Availability which may be expensive to retrieve.

enum TAccessPointFlagFilterValue
	{
	EAccessPointFlagIgnore = 0,   // don't care.. signify we don't want to go and find it out if it requires any effort
	EAccessPointFlagMatchTrue = 1,
	EAccessPointFlagMatchFalse = 2,
	EAccessPointFlagMatchAny = 3,     // find the value out
	};

struct TAccessPointStatusFilter
	{
	union
		{
		struct
			{
			TUint iConfigured:2;
			TUint iRestricted:2;
			TUint iAvailable:2;
			TUint iStarted:2;
			TUint iActive:2;
			} iS;
		TInt64 iAsInt;
		} iU;
	
	TAccessPointStatusFilter(TInt64 aI)
		{
		iU.iAsInt = aI;
		}

	TAccessPointStatusFilter()
		{
		iU.iAsInt = TInt64(0);
		}

	TInt64 AsInt64() const { return iU.iAsInt; }

	void Configured(TAccessPointFlagFilterValue aVal) {iU.iS.iConfigured = aVal;}
	TAccessPointFlagFilterValue Configured() const {return static_cast<TAccessPointFlagFilterValue>(iU.iS.iConfigured);}

	void Restricted(TAccessPointFlagFilterValue aVal) {iU.iS.iRestricted = aVal;}
	TAccessPointFlagFilterValue Restricted() const {return static_cast<TAccessPointFlagFilterValue>(iU.iS.iRestricted);}

	void Available(TAccessPointFlagFilterValue aVal) {iU.iS.iAvailable = aVal;}
	TAccessPointFlagFilterValue Available() const {return static_cast<TAccessPointFlagFilterValue>(iU.iS.iAvailable);}

	void Started(TAccessPointFlagFilterValue aVal) {iU.iS.iStarted = aVal;}
	TAccessPointFlagFilterValue Started() const {return static_cast<TAccessPointFlagFilterValue>(iU.iS.iStarted);}

	void Active(TAccessPointFlagFilterValue aVal) {iU.iS.iActive = aVal;}
	TAccessPointFlagFilterValue Active() const {return static_cast<TAccessPointFlagFilterValue>(iU.iS.iActive);}

	// helper function.. whether given flag value matches given filter
	static TBool Matches(TAccessPointFlagFilterValue aFilter,TAccessPointFlagValue aValue)
		{
		if(aFilter == EAccessPointFlagIgnore)
			{
			return ETrue;
			}

		switch(aValue)
			{
			case EAccessPointFlagFalse:
				if(aFilter != EAccessPointFlagMatchTrue) //i.e. is False/MatchAny
					{
					return ETrue;
					}
				break;

			case EAccessPointFlagTrue:
				if(aFilter != EAccessPointFlagMatchFalse) //i.e. is True/MatchAny
					{
					return ETrue;
					}
				break;
			
			case EAccessPointFlagUnknown:
				if(aFilter == EAccessPointFlagMatchAny) // only if we'll match any
					{
					return ETrue;
					}
				break;
			}
		
		return EFalse;
		}

	static TText FilterValueAsChar(TAccessPointFlagFilterValue aVal)
		{
		switch(aVal)
			{
			case EAccessPointFlagMatchFalse: return 'N';
			case EAccessPointFlagMatchTrue: return 'Y';
			case EAccessPointFlagMatchAny: return '?';
			}
		return '-';
		}

	};



inline void TAccessPointStatus::CopyFieldsRequiredByQueryFrom(const TAccessPointStatusFilter& aFilter,const TAccessPointStatus& aSource)
	{
	if(aFilter.Configured() != EAccessPointFlagIgnore)
		{
		Configured(aSource.Configured());
		}

	if(aFilter.Restricted() != EAccessPointFlagIgnore)
		{
		Restricted(aSource.Restricted());
		}

	if(aFilter.Available() != EAccessPointFlagIgnore)
		{
		Available(aSource.Available());
		}

	if(aFilter.Started() != EAccessPointFlagIgnore)
		{
		Started(aSource.Started());
		}

	if(aFilter.Active() != EAccessPointFlagIgnore)
		{
		Active(aSource.Active());
		}
	}

}
#endif