objectstore.h

GPS Manager is a GUI for downloading, organizing, maintaining, and uploading GPS data (i.e. tracks,

/*
gpsmgr: A program for managing GPS information
Copyright (C) 2003 Austin Bingham

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

You can reach the author at:
    [e-mail]
*/

#ifndef OBJECTSTORE_H
#define OBJECTSTORE_H

#include "exceptions.h"
#include "boost/limits.hpp"
#include <map>

using namespace gpsmgr::exceptions;

namespace gpsmgr { namespace objectstore {

    template <class T>
    class ObjectStore
    {
    public:
	struct NoMoreIDs {};

	typedef unsigned long ID;
	typedef std::map<ID, T> Objects;
	typedef typename Objects::iterator iterator;
	typedef typename Objects::const_iterator const_iterator;

	/** Throws Exception<NoSuchElement> */
	T& get(ID id)
	    {
		typename Objects::iterator itr = mObjects.find(id);
		if (itr == mObjects.end())
		    throw Exception<NoSuchElement>("[ObjectStore::get()] Unable to find object");
		
		return itr->second;
	    }

	/** Throws Exception<NoSuchElement> */
	const T& get(ID id) const
	    {
		typename Objects::const_iterator itr = mObjects.find(id);
		if (itr == mObjects.end())
		    throw Exception<NoSuchElement>("[ObjectStore::get()] Unable to find object");
		
		return itr->second;
	    }

	/** Throws Exception<NoMoreIDs> */
	ID add(const T& obj)
	    {
		using namespace std;
		
		ID id = nextID();
		mObjects[id] = obj;
		
		return id;
	    }
	
	void remove(ID id)
	    {
		mObjects.erase(id);
	    }

	void clear()
	    {
		mObjects.clear();
	    }
	
	iterator begin()
	    {
		return mObjects.begin();
	    }
	
	iterator end()
	    {
		return mObjects.end();
	    }
	
	const_iterator begin() const
	    {
		return mObjects.begin();
	    }
	
	const_iterator end() const
	    {
		return mObjects.end();
	    }
	
    private:
	ID nextID()
	    {
		// TODO: This is pretty ugly...any better heuristic method, perhaps?
		
		// First, if m is empty, return minimum
		if (mObjects.empty())
		    return std::numeric_limits<ID>::min();
		
		// Next, try to find one at the end
		typename Objects::const_reverse_iterator ritr = mObjects.rbegin();
		ID startingPoint = ritr->first;
		for (ID rval = startingPoint + 1;
		     rval != startingPoint;
		     ++rval)
		{
		    if (mObjects.find(rval) == mObjects.end())
			return rval;
		}
		
		throw Exception<NoMoreIDs>("[nextID] No more IDs are available");
	    }
	
    private:
	Objects mObjects;
    };
    
} }

#endif