Class GenericMap

src/common/classes/GenericMap.h:56–377

//
template <typename KeyValuePair, typename KeyComparator = DefaultComparator<typename KeyValuePair::first_type> >
class GenericMap : public AutoStorage
{
private:
	template <typename TGenericMap, typename TAccessor, typename TKeyValuePair>
	class BaseIterator
	{
	public:
		BaseIterator(TGenericMap* map, bool initFinished = false)
			: accessor(map),
			  finished(initFinished)
		{
			if (!initFinished)
				finished = !accessor.getFirst();
		}

	public:
		bool operator !=(const BaseIterator& o)
		{
			return !(
				(finished && o.finished) ||
				((!finished && !o.finished && accessor.current() == o.accessor.current())));
		}

		void operator ++()
		{
			fb_assert(!finished);
			finished = !accessor.getNext();
		}

		TKeyValuePair& operator *()
		{
			fb_assert(!finished);
			return *accessor.current();
		}

	private:
		TAccessor accessor;
		bool finished;
	};

public:
	typedef typename KeyValuePair::first_type KeyType;
	typedef typename KeyValuePair::second_type ValueType;

	typedef BePlusTree<KeyValuePair*, KeyType, FirstObjectKey<KeyValuePair>, KeyComparator> ValuesTree;
	typedef typename ValuesTree::Accessor TreeAccessor;
	typedef typename ValuesTree::ConstAccessor ConstTreeAccessor;

	class Accessor
	{
	public:
		explicit Accessor(GenericMap* map) : m_Accessor(&map->tree) {}

		KeyValuePair* current() const { return m_Accessor.current(); }

		bool getFirst() { return m_Accessor.getFirst(); }
		bool getNext() { return m_Accessor.getNext(); }