WebSVN - Projects - Blame - Rev 2000 - /C-OSD/arducam-osd/libraries/PTPCamera/valuelist.h

Rev	Author	Line No.	Line
1702	-	1	/* Copyright (C) 2010-2011 Circuits At Home, LTD. All rights reserved.
		2
		3	This software may be distributed and modified under the terms of the GNU
		4	General Public License version 2 (GPL2) as published by the Free Software
		5	Foundation and appearing in the file GPL2.TXT included in the packaging of
		6	this file. Please note that GPL2 Section 2[b] requires that all works based
		7	on this software must also be made publicly available under the terms of
		8	the GPL2 ("Copyleft").
		9
		10	Contact information
		11	-------------------
		12
		13	Circuits At Home, LTD
		14	Web : http://www.circuitsathome.com
		15	e-mail : support@circuitsathome.com
		16	*/
		17	#if !defined(__VALUELIST_H__)
		18	#define __VALUELIST_H__
		19
		20	#include <avr/eeprom.h>
		21	#include "WProgram.h"
		22
		23
		24	template <class ValueType, const uint8_t TitleSize>
		25	struct ValueTitle
		26	{
		27	ValueType value;
		28	const char title[TitleSize];
		29	};
		30
		31	template <class ValueType, const uint16_t ListSize>
		32	class ValueList
		33	{
		34	public:
		35	uint16_t listSize;
		36	ValueType valueList[ListSize];
		37	ValueType currentValue;
		38
		39	ValueType GetNext()
		40	{
		41	for (uint16_t i=0; i<listSize; i++)
		42	if (valueList[i] == currentValue)
		43	return ((i+1 < listSize) ? valueList[i+1] : currentValue);
		44
		45	return currentValue;
		46	};
		47
		48	ValueType GetPrev()
		49	{
		50	for (uint16_t i=0; i<listSize; i++)
		51	if (valueList[i] == currentValue)
		52	return ((i-1 >= 0) ? valueList[i-1] : currentValue);
		53
		54	return currentValue;
		55	};
		56	};
		57
		58
		59
		60	template <class ValueType, const uint8_t TitleSize>
		61	const char* FindTitle(uint8_t size, const ValueTitle<ValueType, TitleSize> *p, ValueType val)
		62	{
		63	for (int i=0; i<size; i++)
		64	{
		65	if (pgm_read_byte(&(p[i].value)) == val)
		66	return (const char*)p[i].title;
		67	}
		68	return PSTR("N/A");
		69	}
		70
		71
		72	class EEPROMByteList
		73	{
		74	const uint16_t listOffset;
		75	const uint8_t maxListSize;
		76	uint8_t listSize;
		77
		78	uint16_t GetValueAddress(uint8_t val)
		79	{
		80	uint16_t tail = listOffset+listSize+2;
		81
		82	for (uint16_t i=listOffset+1; i<tail; i++)
		83	if (eeprom_read_byte((uint8_t*)i) == val)
		84	return i;
		85
		86	return 0xffff;
		87	};
		88
		89	public:
		90	EEPROMByteList(uint16_t list_offset, uint16_t max_size) : listOffset(list_offset), maxListSize(max_size), listSize(0)
		91	{
		92	};
		93
		94	uint16_t GetValueIndex(uint8_t val)
		95	{
		96	uint16_t addr = GetValueAddress(val);
		97
		98	return (addr == 0xffff) ? addr : addr - listOffset - 1;
		99	};
		100
		101	void SetSize(uint8_t size)
		102	{
		103	listSize = (size < maxListSize) ? size : maxListSize;
		104
		105	if (eeprom_read_byte((uint8_t*) listOffset) != listSize)
		106	eeprom_write_byte((uint8_t*) listOffset, listSize);
		107	};
		108
		109	uint8_t GetSize()
		110	{
		111	return listSize;
		112	};
		113
		114
		115	uint8_t Get(uint8_t i)
		116	{
		117	return (eeprom_read_byte((uint8_t*)(listOffset + 1 + ((i < listSize) ? i : listOffset+listSize-1))));
		118	};
		119
		120	void Set(uint8_t i, uint8_t val)
		121	{
		122	if (i < listSize)
		123	{
		124	uint16_t pos = listOffset + i + 1;
		125
		126	if (eeprom_read_byte((uint8_t*) pos) != val)
		127	eeprom_write_byte((uint8_t*) pos, val);
		128	}
		129	};
		130
		131	uint8_t GetNext(uint8_t val, uint8_t di=1)
		132	{
		133	uint16_t addr = GetValueAddress(val);
		134
		135	uint16_t tail = listOffset+listSize;
		136
		137	if (addr == 0xffff)
		138	return eeprom_read_byte((uint8_t*)tail);
		139
		140	addr += di;
		141
		142	return eeprom_read_byte((uint8_t*)((addr > tail) ? tail : addr));
		143	};
		144
		145	uint8_t GetPrev(uint8_t val, uint8_t di=1)
		146	{
		147	uint16_t addr = GetValueAddress(val);
		148
		149	if (addr == 0xffff)
		150	return eeprom_read_byte((uint8_t*)(listOffset+1));
		151
		152	addr -= di;
		153
		154	return eeprom_read_byte((uint8_t*)((addr <= listOffset) ? listOffset+1 : addr));
		155	};
		156	};
		157
		158
		159
		160	template <class VALUE_TYPE, const uint16_t MAX_LIST_SIZE>
		161	class SRAMValueList
		162	{
		163	VALUE_TYPE theList[MAX_LIST_SIZE];
		164	uint16_t listSize;
		165
		166	uint16_t GetValueAddress(VALUE_TYPE val)
		167	{
		168	for (uint16_t i=0; i<listSize; i++)
		169	if (theList[i] == val)
		170	return i;
		171
		172	return 0xffff;
		173	};
		174
		175	public:
		176	SRAMValueList() : listSize(0)
		177	{
		178	};
		179
		180	uint16_t GetValueIndex(VALUE_TYPE val)
		181	{
		182	return GetValueAddress(val);
		183	};
		184
		185	void SetSize(uint16_t size)
		186	{
		187	listSize = (size <= MAX_LIST_SIZE) ? size : MAX_LIST_SIZE;
		188	};
		189
		190	uint16_t GetSize()
		191	{
		192	return listSize;
		193	};
		194
		195
		196	VALUE_TYPE Get(uint16_t i)
		197	{
		198	return (theList[(i < listSize) ? i : listSize-1]);
		199	};
		200
		201	void Set(uint16_t i, VALUE_TYPE val)
		202	{
		203	if (i < listSize)
		204	theList[i] = val;
		205	};
		206
		207	void Append(VALUE_TYPE val)
		208	{
		209	if (listSize < MAX_LIST_SIZE)
		210	theList[listSize++] = val;
		211	};
		212
		213	uint8_t GetNext(VALUE_TYPE val, uint8_t di=1)
		214	{
		215	uint16_t addr = GetValueAddress(val);
		216
		217	if (addr == 0xffff)
		218	return theList[(addr < listSize) ? addr : listSize - 1];
		219
		220	addr += di;
		221
		222	return theList[(addr < listSize) ? addr : listSize-1];
		223	};
		224
		225	uint8_t GetPrev(VALUE_TYPE val, uint8_t di=1)
		226	{
		227	uint16_t addr = GetValueAddress(val);
		228
		229	if (addr == 0xffff)
		230	return theList[0];
		231
		232	addr -= di;
		233
		234	return theList[(addr < listSize) ? addr : 0];
		235	};
		236	};
		237
		238	#endif // #define __VALUELIST_H__

Subversion Repositories Projects

(root)/C-OSD/arducam-osd/libraries/PTPCamera/valuelist.h - Rev 2000