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

/**
 @file
 @internalComponent
*/

#include <obexheaders.h>
#include "OBEXUTIL.H"
#include "logger.h"

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, "OBEX");
#endif

/**
Called in response to First() being called on the iterator object.
The default implementation does nothing---some implementations may
wish to reset state variables.

@publishedAll
@released
*/
EXPORT_C void MObexHeaderCheck::Reset()
	{
	LOG_LINE
	LOG_FUNC
	}

/**
This virtual function allows the M- classes to be extended in future in a binary
compatible way by providing a method that clients can override in future to
allow extra callbacks to be made via aObject.
*/	
EXPORT_C void MObexHeaderCheck::MOHC_ExtensionInterfaceL(TUid /*aInterface*/, void*& aObject)
	{
	aObject = NULL;
	}
	
/**
@return ETrue if this header is the requested one.

@publishedAll
@released
*/
EXPORT_C TBool TObexMatchHeader::Interested(TUint8 aHI)
	{
	LOG_LINE
	LOG_FUNC

	return (aHI == iHI);
	}

/**
Sets the header identifier required.
@code : iHI = aHI;
@publishedAll
@released
*/
EXPORT_C void TObexMatchHeader::SetHeader(TUint8 aHI)
	{
	LOG_LINE
	LOG_FUNC

	iHI = aHI;
	}

/**
@return ETrue if this header is of the requested type.
@publishedAll
@released
*/
EXPORT_C TBool TObexMatchHeaderType::Interested(TUint8 aHI)
	{
	LOG_LINE
	LOG_FUNC

	return (ObexHeaderType(aHI) == iType);
	}

/**
Set the header type required.
@code : iType = aType;
@publishedAll
@released
*/
EXPORT_C void TObexMatchHeaderType::SetType(CObexHeader::THeaderType aType)
	{
	LOG_LINE
	LOG_FUNC

	iType = aType;
	}

/**
Creates an empty CObexHeaderSet object.
@publishedAll
@released
*/
EXPORT_C CObexHeaderSet* CObexHeaderSet::NewL()
	{
	LOG_LINE
	LOG_STATIC_FUNC_ENTRY

	CObexHeaderSet* self = new(ELeave) CObexHeaderSet();
	return self;
	}

/**
Copies an existing CObexHeaderSet to populate a new object.
@return A new CObexHeaderSet object populated with the headers.
		This method returns ownership of the new object.
@publishedAll
@released
*/
EXPORT_C CObexHeaderSet* CObexHeaderSet::CopyL()
	{
	LOG_LINE
	LOG_FUNC

	CObexHeaderSet* newHeaderSet = new(ELeave) CObexHeaderSet();
	CleanupStack::PushL(newHeaderSet);
	
	TInt maxHeader = iHeaders.Count();
	for (TInt pos = 0; pos < maxHeader; pos++)
		{
		CObexHeader* newHeader = iHeaders[pos]->CopyL();
		CleanupStack::PushL(newHeader);
		LEAVEIFERRORL(newHeaderSet->iHeaders.Append(newHeader));
		CleanupStack::Pop(newHeader);
		}
	
	CleanupStack::Pop(newHeaderSet);
	return newHeaderSet;
	}
	
/**
Copies interesting headers from an existing CObexHeaderSet to populate a new object.
@param aHeaderCheck The object to use to filter headers of interest.
@return A new CObexHeaderSet object with the desired headers.
		This method returns ownership of the new object.
@publishedAll
@released
*/	
EXPORT_C CObexHeaderSet* CObexHeaderSet::CopyL(MObexHeaderCheck& aHeaderCheck)
	{
	LOG_LINE
	LOG_FUNC

	CObexHeaderSet* newHeaderSet = new(ELeave) CObexHeaderSet();
	CleanupStack::PushL(newHeaderSet);
	
	aHeaderCheck.Reset();
	
	TInt maxHeader = iHeaders.Count();
	for (TInt pos = 0; pos < maxHeader; pos++)
		{
		CObexHeader* header = iHeaders[pos];
		
		if (aHeaderCheck.Interested(header->HI()))
			{
			CObexHeader* newHeader = header->CopyL();
			CleanupStack::PushL(newHeader);
			LEAVEIFERRORL(newHeaderSet->iHeaders.Append(newHeader));
			CleanupStack::Pop(newHeader);
			}
		}
	
	CleanupStack::Pop(newHeaderSet);
	return newHeaderSet;
	}

/**
Constructor
*/
CObexHeaderSet::CObexHeaderSet()
	{
	}

/**
Destructor
This method deletes each individual item that the pointer array 
points at.

@internalComponent
*/
CObexHeaderSet::~CObexHeaderSet()
	{
	iHeaders.ResetAndDestroy();
	}

/**
Adds a header to the set.
@param aHeader pointer to the header to be added.  Ownership is transferred on a
		successful addition.
@return A standard error code giving the results of the insertion.

@publishedAll
@released
*/
EXPORT_C TInt CObexHeaderSet::AddHeader(CObexHeader* aHeader)
	{
	LOG_LINE
	LOG_FUNC

	TInt ret = iHeaders.Append(aHeader);
	
	return ret;
	}

/**
Deletes the current header from the headerset.

@publishedAll
@released
 */
EXPORT_C void CObexHeaderSet::DeleteCurrentHeader()
	{
	LOG_LINE
	LOG_FUNC

	if ((iPos >= 0) && (iPos < iHeaders.Count()))
		{
		delete iHeaders[iPos];
		iHeaders.Remove(iPos);
		}

	First();
	}

/**
Sets a header mask.  Functions will only return values which the
mask claims are interesting.  The only 'accessor' functions which
ignore this mask are the NewL overloads which copy an existing
header set.

The object defaults to a mask where all headers are considered
interesting.  Passing in a null parameter reverts to this behaviour.

@param aMask The mask to use.
@publishedAll
@released
*/
EXPORT_C void CObexHeaderSet::SetMask(MObexHeaderCheck* aMask)
	{
	LOG_LINE
	LOG_FUNC

	iMask = aMask;
	First();
	}

/**
Removes from this header set any headers which the mask claims are
not interesting.  The position of the iterator is reset to the first
remaining header.
The mask will get reset to zero at the end of this method.

@publishedAll
@released
*/
EXPORT_C void CObexHeaderSet::DeleteMasked()
	{
	LOG_LINE
	LOG_FUNC

	First();

	if (!iMask)
		{
		return;
		}
	
	TInt count = iHeaders.Count();
	for (TInt pos = 0; pos < count; /*no iterative step*/)
		{
		TUint8 hi = iHeaders[pos]->HI();
		if (!iMask->Interested(hi))
			{
			delete iHeaders[pos];
			iHeaders.Remove(pos);
			//do not increment pos as old [pos+1] element is now stored in [pos]
			count--;
			}
		else
			{
			pos++;
			}
		}
	
	iMask = 0;
	
	First();
	}

/**
Resets the mask, then advances the iterator to the first interesting header.

@publishedAll
@released
*/
EXPORT_C void CObexHeaderSet::First() const
	{
	LOG_LINE
	LOG_FUNC

	iPos = 0;

	if (iMask)
		{
		iMask->Reset();
		}
	
	if (Next(0) == KErrNotFound)
		{
		iPos = -1;
		}
	}

/**
Links the supplied header to the same underlying header that is used by the 
iterator's current header.
@param aHeader The header object to populate.
@return KErrNotFound if the iterator is not currently pointing to a valid
		header.
@publishedAll
@released	
*/
EXPORT_C TInt CObexHeaderSet::This(CObexHeader* aHeader) const
	{
	LOG_LINE
	LOG_FUNC

	if (iPos < 0)
		{
		return KErrNotFound;
		}
	
	aHeader->Set(iHeaders[iPos]);
	return KErrNone;
	}

/**
Advances the iterator to the next interesting header, skipping over the current header before
starting to search.
@return KErrNotFound if there are no more interesting headers in the set.
@publishedAll
@released
*/
EXPORT_C TInt CObexHeaderSet::Next() const
	{
	return Next(1);
	}

/**
Advances the iterator to the next interesting header, skipping over aSkip headers before
starting to search.
@param aSkip The minimum number of headers to move on from the current position, 
independant of whether a mask has been set or not.
A value of zero therefore makes Next() essentially a no-op but presents the current
header to the header filter again.
@return KErrNotFound if there are no more interesting headers in the set.
@publishedAll
@released
*/
EXPORT_C TInt CObexHeaderSet::Next(TInt aSkip) const
	{
	// Don't log this function as it's too verbose.
	//LOG_LINE
	//LOG_FUNC

	iPos += aSkip;
	TInt count = iHeaders.Count();
	
	if (iMask)
		{
		for (; iPos < count; iPos++)
			{
			TUint8 hi = iHeaders[iPos]->HI();
			if (iMask->Interested(hi))
				break;
			}
		}

	if (iPos >= count)
		{
		iPos = -1;
		}
	
	return (iPos < 0) ? KErrNotFound : KErrNone;
	}

/**
Returns the total number of headers in this set, ie. ignores the mask.
@return Count of the total number of headers (masked and unmasked) in this set.
@released
*/
EXPORT_C TInt CObexHeaderSet::Count() const
	{
	LOG_LINE
	LOG_FUNC

	return iHeaders.Count();
	}

/**
Returns the first instance of the header with the required HI value
by inserting it into the supplied CObexHeader object.  This uses the
standard iterator functionality, so is limited by the current mask, and
starts from the current iterator position.
@param aHI The header to search for.  Consult the Obex specification for values.
@param aHeader The header object to populate.
@return KErrNotFound if the header was not present.
*/
EXPORT_C TInt CObexHeaderSet::Find(TUint8 aHI, CObexHeader& aHeader) const
	{
	LOG_LINE
	LOG_FUNC

    if (iPos >= iHeaders.Count()) 
        {
        // Already searched all available headers
        return KErrNotFound;
        }
    
    if (iPos >= 0)
    	{
		TUint8 hi = iHeaders[iPos]->HI();
		TInt err = KErrNone;
		while ((err == KErrNone) &&
			   (hi != aHI))
			{
			err = Next();
			if (err == KErrNone)
				{
				hi = iHeaders[iPos]->HI();
				}
			}
		
		if (hi == aHI)
			{
			aHeader.Set(iHeaders[iPos]);
			return KErrNone;
			}
		else
			{
			return KErrNotFound;
			}
		}
	else
		{
		return KErrNotFound;
		}
	}