ClassLoader.h

Go to the documentation of this file.

/* Copyright © 2009 James Legg.
    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 3 of the License, or
    (at your option) any later version.
*/

#ifndef LIBTRACK_CLASS_LOADER_H
#define LIBTRACK_CLASS_LOADER_H

#include <iostream>
#include <map>
#include <vector>
#include <string>

#include <boost/shared_ptr.hpp>

#include "FormErrors.h"
#include "stream_loader.h"

namespace Track
{

class Savable
{
    virtual std::string get_class_identifier() const = 0;
};

class  ClassLoaderBase
{
    public:
        virtual boost::shared_ptr<Savable> create(std::istream & source) const = 0;
        
        virtual std::string get_identifier() const = 0;
};

template <class T>
class ClassLoader;

const unsigned int latest_class_record_version = 1;
const unsigned int latest_class_record_vector_version = 1;

void register_all_classes_with_savable_class_list();

class SaveableClassList
{
    private:
        SaveableClassList();
        SaveableClassList(const SaveableClassList & source);
        bool operator=(const SaveableClassList & source);
    public:
        static SaveableClassList * get_instance();
        
        template <class T>
        void register_class(ClassLoader<T> * loader)
        {
            loaders.insert(std::pair<std::string, ClassLoader<T> *>(loader->get_identifier(), loader));
        }
        
        template<class T>
        boost::shared_ptr<T> load_object(std::istream & source)
        {
            register_all_classes_with_savable_class_list();
            unsigned int version;
            source >> version;
            if (version < latest_class_record_version)
            {
                throw DepreciatedVersionError();
            }
            else if (version > latest_class_record_version)
            {
                throw NewVersionError();
            }
            std::string type;
            type = string_from_stream(source);
            std::map<std::string, ClassLoaderBase *>::iterator it = loaders.find(type);
            if (it == loaders.end())
            {
                // couldn't find the object, probably a new one.
                assert(false);
                throw UnkownObjectError();
            }
            boost::shared_ptr<T> ptr = boost::dynamic_pointer_cast<T, Savable>(it->second->create(source));
            if (!ptr)
            {
                // Not a base class of the requested type.
                // Classes changed so this is invalid.
                assert(false);
                throw WrongTypeError();
            }
            return ptr;
        }
        
        template <class T>
        void write_object(std::ostream & destination, const T & object)
        {
            destination << latest_class_record_version << " ";
            string_to_stream(destination, object.get_class_identifier());
            destination << ' ' << object;
        }
        
        template <class T>
        void fill_vector(std::istream & source, std::vector<boost::shared_ptr<T> > & vector)
        {
            unsigned int version;
            source >> version;
            if (version < latest_class_record_vector_version)
            {
                throw DepreciatedVersionError();
            }
            else if (version > latest_class_record_vector_version)
            {
                throw NewVersionError();
            }
            // how many items were saved?
            std::size_t size;
            source >> size;
            vector.reserve(size);
            // load each one.
            for (unsigned int index = 0; index < size; index++)
            {
                boost::shared_ptr<T> ptr(load_object<T>(source));
                vector.push_back(ptr);
            }
        }
        
        template <class Container>
        void write_vector(std::ostream & destination, const Container & vector)
        {
            destination << latest_class_record_vector_version << ' ';
            destination << vector.size();
            for (typename Container::const_iterator it = vector.begin();
                 it != vector.end();
                 it++)
            {
                destination << ' ';
                write_object(destination, **it);
            }
        }
    private:
        std::map<std::string, ClassLoaderBase *> loaders;
};

template <class T>
class ClassLoader
    :   public ClassLoaderBase
{
    public:
        ClassLoader(std::string name)
            :   m_name(name)
        {
            SaveableClassList::get_instance()->register_class(this);
        }
        
        virtual boost::shared_ptr<Savable> create(std::istream & source) const
        {
            boost::shared_ptr<Savable> result(new T(source));
            return result;
        }
        
        virtual std::string get_identifier() const
        {
            return m_name;
        }
    protected:
        std::string m_name;
};

} // namespace Track

#endif // LIBTRACK_CLASS_LOADER_H

---

Generated at Mon Sep 6 00:41:11 2010 by Doxygen version 1.4.7 for Racer version svn335.