ClassLoader.h

Go to the documentation of this file.

//
// ClassLoader.h
//
// $Id: //poco/1.3/Foundation/include/Poco/ClassLoader.h#2 $
//
// Library: Foundation
// Package: SharedLibrary
// Module:  ClassLoader
//
// Definition of the ClassLoader class.
//
// Copyright (c) 2004-2006, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// Permission is hereby granted, free of charge, to any person or organization
// obtaining a copy of the software and accompanying documentation covered by
// this license (the "Software") to use, reproduce, display, distribute,
// execute, and transmit the Software, and to prepare derivative works of the
// Software, and to permit third-parties to whom the Software is furnished to
// do so, all subject to the following:
// 
// The copyright notices in the Software and this entire statement, including
// the above license grant, this restriction and the following disclaimer,
// must be included in all copies of the Software, in whole or in part, and
// all derivative works of the Software, unless such copies or derivative
// works are solely in the form of machine-executable object code generated by
// a source language processor.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
// FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
// ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//


#ifndef Foundation_ClassLoader_INCLUDED
#define Foundation_ClassLoader_INCLUDED


#include "Poco/Foundation.h"
#include "Poco/MetaObject.h"
#include "Poco/Manifest.h"
#include "Poco/SharedLibrary.h"
#include "Poco/Mutex.h"
#include "Poco/Exception.h"
#include <map>
#include <vector>

namespace Poco {


template <class Base>
class ClassLoader
{
public:
        typedef AbstractMetaObject<Base> Meta;
        typedef Manifest<Base> Manif;
        typedef void (*InitializeLibraryFunc)();
        typedef void (*UninitializeLibraryFunc)();
        typedef bool (*BuildManifestFunc)(ManifestBase*);

        typedef std::pair<const Manif*, std::string> manifest_pair;

        struct LibraryInfo
        {
                SharedLibrary* pLibrary;
                std::vector< manifest_pair >   vpManifest;
                int            refCount;
        };
        typedef std::map<std::string, LibraryInfo> LibraryMap;

        class Iterator
        {
        public:
                typedef std::pair<std::string, std::vector<manifest_pair> > Pair;

                Iterator(const typename LibraryMap::const_iterator& it)
                {
                        _it = it;
                }
                Iterator(const Iterator& it)
                {
                        _it = it._it;
                }
                ~Iterator()
                {
                }
                Iterator& operator = (const Iterator& it)
                {
                        _it = it._it;
                        return *this;
                }
                inline bool operator == (const Iterator& it) const
                {
                        return _it == it._it;
                }
                inline bool operator != (const Iterator& it) const
                {
                        return _it != it._it;
                }
                Iterator& operator ++ () // prefix
                {
                        ++_it;
                        return *this;
                }
                Iterator operator ++ (int) // postfix
                {
                        Iterator result(_it);
                        ++_it;
                        return result;
                }
                inline const Pair* operator * () const
                {
                        _pair.first  = _it->first;
                        _pair.second = _it->second.vpManifest;
                        return &_pair;
                }
                inline const Pair* operator -> () const
                {
                        _pair.first  = _it->first;
                        _pair.second = _it->second.vpManifest;
                        return &_pair;
                }

        private:
                typename LibraryMap::const_iterator _it;
                mutable Pair _pair;
        };

        ClassLoader()
        {
        }

        virtual ~ClassLoader()
        {
                for (typename LibraryMap::const_iterator it = _map.begin(); it != _map.end(); ++it)
                {
                        delete it->second.pLibrary;
                        for (unsigned int i = 0 ; i < it->second.vpManifest.size(); i++)
                        {
                          delete it->second.vpManifest[i].first;
                        }
                }
        }

        void loadLibrary(const std::string& path, const std::string& manifest)
        {
                FastMutex::ScopedLock lock(_mutex);

                typename LibraryMap::iterator it = _map.find(path);
                if (it == _map.end())
                {
                        LibraryInfo li;
                        li.pLibrary  = new SharedLibrary(path);
                        li.vpManifest.push_back( manifest_pair(new Manif(), manifest));
                        li.refCount  = 1;
                        try
                        {
                                std::string pocoBuildManifestSymbol("pocoBuildManifest");
                                pocoBuildManifestSymbol.append(manifest);
                                if (li.pLibrary->hasSymbol("pocoInitializeLibrary"))
                                {
                                        InitializeLibraryFunc initializeLibrary = (InitializeLibraryFunc) li.pLibrary->getSymbol("pocoInitializeLibrary");
                                        initializeLibrary();
                                }
                                if (li.pLibrary->hasSymbol(pocoBuildManifestSymbol))
                                {
                                        BuildManifestFunc buildManifest = (BuildManifestFunc) li.pLibrary->getSymbol(pocoBuildManifestSymbol);
                                        if (buildManifest(const_cast<Manif*>(li.vpManifest.back().first))){
                                                _map[path] = li;
                                        }
                                        else
                                                throw LibraryLoadException(std::string("Manifest class mismatch in ") + path, manifest);
                                }
                                else throw LibraryLoadException(std::string("No manifest in ") + path, manifest);
                        }
                        catch (...)
                        {
                                delete li.pLibrary;
                                delete li.vpManifest.back().first; //known only one long
                                li.vpManifest.pop_back();
                                _map.erase(path);
                                throw;
                        }
                }
                else
                {
                  bool found = false;
                  for (unsigned int i = 0; i < it->second.vpManifest.size(); i++)
                  {
                    if (manifest == it->second.vpManifest[i].second)
                    {
                      found = true;
                      break;
                    }
                  }
                  if ( !found)
                  {
                    //\TODO make this a function call for cut and paste from above
                    try
                        {
                                std::string pocoBuildManifestSymbol("pocoBuildManifest");
                                pocoBuildManifestSymbol.append(manifest);
                                if (it->second.pLibrary->hasSymbol("pocoInitializeLibrary"))
                                {
                                        InitializeLibraryFunc initializeLibrary = (InitializeLibraryFunc) it->second.pLibrary->getSymbol("pocoInitializeLibrary");
                                        initializeLibrary();
                                }
                                if (it->second.pLibrary->hasSymbol(pocoBuildManifestSymbol))
                                {
                                        BuildManifestFunc buildManifest = (BuildManifestFunc) it->second.pLibrary->getSymbol(pocoBuildManifestSymbol);
                                        if (it->second.vpManifest.empty() || !buildManifest(const_cast<Manif*>(it->second.vpManifest.back().first))){   
                                                throw LibraryLoadException(std::string("Manifest class mismatch in ") + path, manifest);
                                        }
                                }
                                else throw LibraryLoadException(std::string("No manifest in ") + path, manifest);
                        }
                        catch (LibraryLoadException& ex)
                        {
                          // don't delete here for there are other manifests using it delete it->second.pLibrary;
                                typename std::vector< manifest_pair >::iterator man_it = it->second.vpManifest.begin();
                                for(;man_it != it->second.vpManifest.end(); ++man_it){
                                        if(man_it->second == manifest){
                                                delete man_it->first; //only last one
                                                it->second.vpManifest.erase(man_it);
                                                break;
                                        }
                                }
                                throw;
                        }
                  }
                  
                        ++it->second.refCount;
                }
        }

        void loadLibrary(const std::string& path)
        {
                loadLibrary(path, "");
        }
                
        void unloadLibrary(const std::string& path)
        {
                FastMutex::ScopedLock lock(_mutex);

                typename LibraryMap::iterator it = _map.find(path);
                if (it != _map.end())
                {
                        if (--it->second.refCount == 0)
                        {
                                if (it->second.pLibrary->hasSymbol("pocoUninitializeLibrary"))
                                {
                                        UninitializeLibraryFunc uninitializeLibrary = (UninitializeLibraryFunc) it->second.pLibrary->getSymbol("pocoUninitializeLibrary");
                                        uninitializeLibrary();
                                }


                                for (unsigned int i = 0 ; i < it->second.vpManifest.size(); i++)
                                {
                                  delete it->second.vpManifest[i].first;
                                }
                                
                                it->second.pLibrary->unload();
                                delete it->second.pLibrary;
                                _map.erase(it);
                        }
                }
                else throw NotFoundException(path);
        }

        const Meta* findClass(const std::string& className) const
        {
                FastMutex::ScopedLock lock(_mutex);

                for (typename LibraryMap::const_iterator it = _map.begin(); it != _map.end(); ++it)
                {
                  for (unsigned int i = 0 ; i < it->second.vpManifest.size(); i++)
                  {
                  
                        const Manif* pManif = it->second.vpManifest[i].first;
                        typename Manif::Iterator itm = pManif->find(className);
                        if (itm != pManif->end())
                                return *itm;
                  }
                }
                return 0;
        }
        
        const Meta& classFor(const std::string& className) const
        {
                const Meta* pMeta = findClass(className);
                if (pMeta)
                        return *pMeta;
                else
                        throw NotFoundException(className);
        }
        
        Base* create(const std::string& className) const
        {
                return classFor(className).create();
        }
        
        Base& instance(const std::string& className) const
        {
                return classFor(className).instance();
        }
        
        bool canCreate(const std::string& className) const
        {
                return classFor(className).canCreate();
        }

        void destroy(const std::string& className, Base* pObject) const
        {
                classFor(className).destroy(pObject);
        }

        bool isAutoDelete(const std::string& className, Base* pObject) const
        {
                return classFor(className).isAutoDelete(pObject);
        }
        
        std::vector<manifest_pair> findManifest(const std::string& path) const
        {
                FastMutex::ScopedLock lock(_mutex);

                typename LibraryMap::const_iterator it = _map.find(path);
                if (it != _map.end())
                        return it->second.vpManifest;
                else
                        return 0;
        }
        
        const Manif& manifestFor(const std::string& path) const
        {
                const Manif* pManif = findManifest(path);
                if (pManif)
                        return *pManif;
                else
                        throw NotFoundException(path);
        }

        bool isLibraryLoaded(const std::string& path) const
        {
                return findManifest(path) != 0;
        }

        Iterator begin() const
        {
                FastMutex::ScopedLock lock(_mutex);

                return Iterator(_map.begin());
        }

        Iterator end() const
        {
                FastMutex::ScopedLock lock(_mutex);

                return Iterator(_map.end());
        }

private:
        LibraryMap _map;
        mutable FastMutex _mutex;
};


} // namespace Poco


#endif // Foundation_ClassLoader_INCLUDED