ptpcallback.h

/* Copyright (C) 2010-2011 Circuits At Home, LTD. All rights reserved.

This software may be distributed and modified under the terms of the GNU
General Public License version 2 (GPL2) as published by the Free Software
Foundation and appearing in the file GPL2.TXT included in the packaging of
this file. Please note that GPL2 Section 2[b] requires that all works based
on this software must also be made publicly available under the terms of
the GPL2 ("Copyleft").

Contact information
-------------------

Circuits At Home, LTD
Web      :  http://www.circuitsathome.com
e-mail   :  support@circuitsathome.com
*/
#ifndef __PTPCALLBACK_H__
#define __PTPCALLBACK_H__

#include <inttypes.h>
#include <avr/pgmspace.h>
#include "WProgram.h"

// Base class for incomming data parser
class PTPReadParser
{
public:
	virtual void Parse(const uint16_t len, const uint8_t *pbuf, const uint32_t &offset) = 0;
};

struct MultiValueBuffer
{
	uint8_t		valueSize;
	void		*pValue;
};

class MultiByteValueParser
{
	uint8_t				* pBuf;
	uint8_t				countDown;
	uint8_t				valueSize;

public:
	MultiByteValueParser() : pBuf(NULL), countDown(0), valueSize(0) {};

	const uint8_t* GetBuffer() { return pBuf; };

	void Initialize(MultiValueBuffer * const pbuf) 
	{ 
		pBuf = (uint8_t*)pbuf->pValue; 
		countDown = valueSize = pbuf->valueSize; 
	};

	bool Parse(uint8_t **pp, uint16_t *pcntdn);
};

class ByteSkipper
{
	uint8_t				*pBuf;
	uint8_t				nStage;
	uint16_t			countDown;

public:
	ByteSkipper() : pBuf(NULL), nStage(0), countDown(0) {};

	void Initialize(MultiValueBuffer *pbuf) 
	{ 
		pBuf = (uint8_t*)pbuf->pValue; 
		countDown = 0; 
	};

	bool Skip(uint8_t **pp, uint16_t *pcntdn, uint16_t bytes_to_skip)
	{
		switch (nStage)
		{
		case 0:
			countDown = bytes_to_skip;
			nStage ++;
		case 1:
			for (; countDown && (*pcntdn); countDown--, (*pp)++, (*pcntdn)--);

			if (!countDown)
				nStage = 0;
		};
		return (!countDown);
	};
};

// Pointer to a callback function triggered for each element of PTP array when used with PTPArrayParser
typedef void (*PTP_ARRAY_EL_FUNC)(const MultiValueBuffer * const p, uint32_t count, const void *me);

class PTPListParser
{
public:
	enum ParseMode { modeArray, modeRange/*, modeEnum*/ };

private:
	uint8_t				nStage;
	uint8_t				enStage;

	uint32_t			arLen;
	uint32_t			arLenCntdn;

	uint8_t				lenSize;		// size of the array length field in bytes
	uint8_t				valSize;		// size of the array element in bytes

	MultiValueBuffer		*pBuf;

	// The only parser for both size and array element parsing
	MultiByteValueParser				theParser;

	uint8_t /*ParseMode*/			prsMode;

public:
	PTPListParser() : 
		pBuf(NULL), 
		nStage(0), 
		enStage(0), 
		arLenCntdn(0), 
		arLen(0),
		lenSize(0),
		valSize(0),
		prsMode(modeArray)
		{};

	void Initialize(const uint8_t len_size, const uint8_t val_size, MultiValueBuffer * const p, const uint8_t mode = modeArray) 
	{ 
		pBuf	= p; 
		lenSize	= len_size;
		valSize = val_size;
		prsMode = mode;

		if (prsMode == modeRange)
		{
			arLenCntdn = arLen = 3;
			nStage = 2;
		}
		else 
		{
			arLenCntdn = arLen = 0;
			nStage = 0;
		}
		enStage = 0;
		theParser.Initialize(p);
	};

	bool Parse(uint8_t **pp, uint16_t *pcntdn, PTP_ARRAY_EL_FUNC pf, const void *me = NULL);
};


// Base class for outgoing data supplier
class PTPDataSupplier
{
public:
	virtual uint32_t GetDataSize() = 0;
	virtual void GetData(const uint16_t len, uint8_t *pbuf) = 0;
};

#endif // __PTPCALLBACK_H__