src.main/CjVisitorFactory.hh

/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
/*
 * mitie
 * Copyright (C) Jason Spencer 2009 <mitie@jasonspencer.org>
 * 
 * mitie 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.
 * 
 * mitie 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, see <http://www.gnu.org/licenses/>.
 */
#ifndef _CJVISITORFACTORY_H_
#define _CJVISITORFACTORY_H_ 1

#include <map>
#include <vector>
#include <iostream>
#include <utility>      // for pair
#include <stdexcept>    // for runtime_error

#ifdef _WIN32
#include <windows.h>    // for HINSTANCE etc..
#endif

#ifndef BUILD_STATIC_MITIE
#ifdef _WIN32
// work in progress..
extern __declspec(dllimport) int init();
extern __declspec(dllimport) int func(int*);
extern __declspec(dllimport) int fini();
#else
#include <dlfcn.h>      // for dlopen, dlclose, dlerror, dlsym
#endif  // not _WIN32
#endif // BUILD_STATIC_MITIE


#include <boost/shared_ptr.hpp>
#include <boost/random.hpp>
#define BOOST_FILESYSTEM_NO_DEPRECATED
#include <boost/filesystem/operations.hpp>
#include <boost/filesystem/path.hpp>
#include "JLOG.hh"

namespace jmitie {

class Cj_NotFoundInFactoryException : public std::runtime_error {
        public:
        explicit Cj_NotFoundInFactoryException (const std::string & message) : std::runtime_error(message) {}
        virtual ~Cj_NotFoundInFactoryException() throw() {}
};

class Cj_NameCollisionException : public std::runtime_error {
        public:
        explicit Cj_NameCollisionException (const std::string & message) : std::runtime_error(message) {}
        virtual ~Cj_NameCollisionException() throw() {}
};

class Cj_SymbolMissingException : public std::runtime_error {
        public:
        explicit Cj_SymbolMissingException (const std::string & message) : std::runtime_error(message) {}
        virtual ~Cj_SymbolMissingException() throw() {}
};

class Cj_DLLException : public std::runtime_error {
        public:
        explicit Cj_DLLException (const std::string & message) : std::runtime_error(message) {}
        virtual ~Cj_DLLException() throw() {}
};

class Cj_FileSystemException : public std::runtime_error {
        public:
        explicit Cj_FileSystemException (const std::string & message) : std::runtime_error(message) {}
        virtual ~Cj_FileSystemException() throw() {}
};

#ifdef _WIN32
typedef HINSTANCE DLLHandle_t;
#else
typedef void * DLLHandle_t;
#endif

template <class VisitorType_t> class CjVisitorFactoryEntry {            // each entry in the factory looks like this - in it we store pointers to sub-factory functions which will create the objects for us
public:
        typedef VisitorType_t VisitorType;
        typedef VisitorType * (* f_create_t)(const std::string & type_name, const std::string & args, const typename VisitorType::ctor_va_t & var_arg );
        typedef std::vector< std::string > (* f_getNames_t)();
        typedef void (* f_destroy_t)(VisitorType *);
        typedef std::string (* f_getProperty_t)(const std::string & type_name, const std::string & prop_name );

private:
        CjVisitorFactoryEntry(const CjVisitorFactoryEntry<VisitorType> &);      // prevent copying as destruction unloads the DLL
        DLLHandle_t m_h;        // handle to the dll (if the function pointers below refer to DLLs)
        std::string m_fname;
        f_create_t m_c; // pointer to the create_t funtion
        f_destroy_t m_d;        // pointer to the destroy_t funtion
        f_getNames_t m_n;       // pointer to the getName_t function
        f_getProperty_t m_p;    // pointer to the getProperty function

public:
        std::string fname() const { return m_fname; }
        f_create_t c() const { return m_c; }
        f_destroy_t d() const { return m_d; }
        f_getNames_t n() const { return m_n; }
        f_getProperty_t p() const { return m_p; }


        CjVisitorFactoryEntry ( f_create_t c, f_destroy_t d, f_getNames_t n, f_getProperty_t p ):m_h(0),m_fname("static"),m_c(c),m_d(d),m_n(n),m_p(p) { }

#ifndef BUILD_STATIC_MITIE
#ifdef _WIN32


        CjVisitorFactoryEntry (const char * fname, const char * create_name, const char * destroy_name, const char * getnames_name, const char * getproperty_name):m_h(0),m_fname(fname),m_c(0),m_d(0),m_n(0),m_p(0) {
                HINSTANCE lib_handle;   // http://drdobbs.com/parallel/232601605
JLOG(4,         std::cout << "CjVisitorFactoryEntry<VisitorType_t>::CjVisitorFactoryEntry<VisitorType_t>(): Loading DLL: " << fname << std::endl; )
JLOG(5,         std::cout << "CjVisitorFactoryEntry<VisitorType_t>::CjVisitorFactoryEntry<VisitorType_t>(): Checking for functions " << create_name << ", "  << destroy_name << " and " << getnames_name << "." << std::endl; )
                m_h = LoadLibrary(TEXT(fname.c_str()));
                if(!m_h) { throw Cj_DLLException(std::string("Error when loading library ") + fname ); }
                m_c = GetProcAddress(lib_handle, "init");
                m_c = (f_create_t) dlsym( m_h, create_name );
                dl_error = dlerror();
                if(dl_error) {
                        dlclose(m_h);
                        throw Cj_SymbolMissingException(std::string("Error when finding function ") + create_name + " in DLL " + fname + ": " + dl_error);
                }
                m_d = (f_destroy_t) dlsym( m_h, destroy_name );
                dl_error = dlerror();
                if(dl_error) {
                        dlclose(m_h);
                        throw Cj_SymbolMissingException(std::string("Error when finding function ") + destroy_name + " in DLL " + fname + ": " + dl_error);
                }
                m_n = (f_getNames_t) dlsym( m_h, getnames_name );
                dl_error = dlerror();
                if(dl_error) {
                        dlclose(m_h);
                        throw Cj_SymbolMissingException(std::string("Error when finding function ") + getnames_name + " in DLL " + fname + ": " + dl_error);
                }
                m_p = (f_getProperty_t) dlsym( m_h, getproperty_name );
                dl_error = dlerror();
                if(dl_error) {
                        dlclose(m_h);
                        throw Cj_SymbolMissingException(std::string("Error when finding function ") + getproperty_name + " in DLL " + fname + ": " + dl_error);
                }
JLOG(4,         std::cout << "CjVisitorFactoryEntry<VisitorType_t>::CjVisitorFactoryEntry<VisitorType_t>(): Loaded DLL: " << fname << std::endl; )
        }
#else

        CjVisitorFactoryEntry (const char * fname, const char * create_name, const char * destroy_name, const char * getnames_name, const char * getproperty_name):m_h(0),m_fname(fname),m_c(0),m_d(0),m_n(0),m_p(0) {
                char * dl_error = dlerror();    // reset errors
JLOG(4,         std::cout << "CjVisitorFactoryEntry<VisitorType_t>::CjVisitorFactoryEntry<VisitorType_t>(): Loading DLL: " << fname << std::endl; )
JLOG(5,         std::cout << "CjVisitorFactoryEntry<VisitorType_t>::CjVisitorFactoryEntry<VisitorType_t>(): Checking for functions " << create_name << ", "  << destroy_name << " and " << getnames_name << "." << std::endl; )
                m_h = dlopen(fname, RTLD_NOW | RTLD_LOCAL);
                dl_error = dlerror();
                if(dl_error) { throw Cj_DLLException(std::string("Error when loading library ") + fname + ": " + dl_error); }
                if(!m_h) { throw Cj_DLLException(std::string("Error when loading library ") + fname + ": reason unkown."); }
                m_c = (f_create_t) dlsym( m_h, create_name );
                dl_error = dlerror();
                if(dl_error) {
                        dlclose(m_h);
                        throw Cj_SymbolMissingException(std::string("Error when finding function ") + create_name + " in DLL " + fname + ": " + dl_error);
                }
                m_d = (f_destroy_t) dlsym( m_h, destroy_name );
                dl_error = dlerror();
                if(dl_error) {
                        dlclose(m_h);
                        throw Cj_SymbolMissingException(std::string("Error when finding function ") + destroy_name + " in DLL " + fname + ": " + dl_error);
                }
                m_n = (f_getNames_t) dlsym( m_h, getnames_name );
                dl_error = dlerror();
                if(dl_error) {
                        dlclose(m_h);
                        throw Cj_SymbolMissingException(std::string("Error when finding function ") + getnames_name + " in DLL " + fname + ": " + dl_error);
                }
                m_p = (f_getProperty_t) dlsym( m_h, getproperty_name );
                dl_error = dlerror();
                if(dl_error) {
                        dlclose(m_h);
                        throw Cj_SymbolMissingException(std::string("Error when finding function ") + getproperty_name + " in DLL " + fname + ": " + dl_error);
                }
JLOG(4,         std::cout << "CjVisitorFactoryEntry<VisitorType_t>::CjVisitorFactoryEntry<VisitorType_t>(): Loaded DLL: " << fname << std::endl; )
        }
#endif  // not _WIN32
#endif // BUILD_STATIC_MITIE
        ~CjVisitorFactoryEntry() {
#ifndef BUILD_STATIC_MITIE
JLOG(4,         std::cout << "Closing DLL " << m_fname << std::endl; )
                if(m_h) dlclose(m_h);
#endif // BUILD_STATIC_MITIE
        }
};

// TODO remove the term Visitor from the name CjVisitorFactory- it might not be a visitor that is being created by the factory - it's generic enough to create other types of objects
// TODO templatize the arguments to the constructed object - would be nice to have mpl::list<std::string, va_t>
template <typename FacEntryType > class CjVisitorFactory {
public:
typedef typename FacEntryType::f_create_t f_create_t;
typedef typename FacEntryType::f_destroy_t f_destroy_t;
typedef typename FacEntryType::f_getNames_t f_getNames_t;
typedef typename FacEntryType::f_getProperty_t f_getProperty_t;
typedef typename FacEntryType::VisitorType VisitorType;
typedef boost::shared_ptr<VisitorType> Visitor_shared_ptr;
typedef typename VisitorType::ctor_va_t VisitorArgumentType;

protected:
typedef std::map< std::string, boost::shared_ptr< FacEntryType >, std::less<std::string> > factory_t;
factory_t m_factory;
std::string m_description;

private:
CjVisitorFactory(const CjVisitorFactory &);     // prevent copying

public:
CjVisitorFactory(const char * desc):m_description(desc) {}
std::string description() const { return m_description; }


~CjVisitorFactory() {
        JLOG(5, std::cout << "CjVisitorFactory::~CjVisitorFactory() called on factory \"" << m_description << "\"." << std::endl; )
        clear();
        }

void clear() {
JLOG(5, std::cout << "CjVisitorFactory::clear() called on factory \"" << m_description << "\"." << std::endl; )
        m_factory.clear();
        }


void registerStaticEntry ( f_create_t c, f_destroy_t d, f_getNames_t n, f_getProperty_t p ) {
        boost::shared_ptr<FacEntryType> fe (new FacEntryType ( c, d, n, p ));
        std::vector< std::string > obj_names ( (*n)() );
JLOG(4, std::cout << "CjVisitorFactory::CjVisitorFactory: Adding static entries to factory.." << std::endl; )
        for(std::vector< std::string >::const_iterator i = obj_names.begin(); i != obj_names.end(); ++i ) {
JLOG(5,         std::cout << "CjVisitorFactory::CjVisitorFactory: Adding static "  << *i << " to factory" << std::endl; )
                m_factory.insert( make_pair ( *i, fe ) );
        }
}

#ifndef BUILD_STATIC_MITIE
// TODO: object properties should include a version field maybe which will be tested here

void loadAll( const char * create_name, const char * destroy_name, const char * getnames_name, const char * getproperty_name, const char * dir = NULL, const bool continueOnFail = false, const bool overwriteExisting = false) {
        namespace fs = boost::filesystem;
        typedef std::vector< std::string > filelist_t;

        // compile a list of files with a .so extension in directory dir 
#ifdef _WIN32
        std::string ext(".dll");
#else
        std::string ext(".so");
#endif
        filelist_t fnamelist;

        fs::path full_path( (dir==NULL) ? fs::initial_path<fs::path>() : fs::system_complete( fs::path( dir ) ) );

        if ( !fs::exists( full_path ) ) throw Cj_FileSystemException(std::string(full_path.file_string()) + " does not exist");
        if ( !fs::is_directory( full_path ) ) throw Cj_FileSystemException(std::string(dir) + " must be a directory");

        fs::directory_iterator end_iter;
        for ( fs::directory_iterator dir_itr( full_path ); dir_itr != end_iter; ++dir_itr ) {
                try {
                                if ( fs::is_regular_file( dir_itr->status() ) && (0 == ext.compare(dir_itr->path().extension()) ) ) {
                                        fnamelist.push_back( dir_itr->path().string() );
                                }
                } catch ( const std::exception & ex ) {
JLOG(2,                 std::cout << "Exception caught in CjVisitorFactory::loadAll:" << dir_itr->path().filename() << " " << ex.what() << std::endl; )
                        std::cout << "Exception caught in CjVisitorFactory::loadAll when creating file list:" << dir_itr->path().filename() << " " << ex.what() << std::endl;
                        throw Cj_FileSystemException("Exception in CjVisitorFactory::loadAll when checking " + dir_itr->path().filename() + " for file list: " + ex.what() );
                }
      }
        
        // dynamically load the files in fnamelist
        factory_t new_factory(m_factory);       // in the end this will be a copy of the existing factory with the new entries appended

        for( filelist_t::const_iterator it = fnamelist.begin(); it != fnamelist.end(); ++it ) {
                factory_t loaded_factory;       // a map of the new entries from file *it
                try {
                        loaded_factory = loadOneDLLToFactoryCopy( it->c_str(), create_name, destroy_name, getnames_name, getproperty_name, continueOnFail, overwriteExisting, &new_factory ); // throws Cj_NameCollisionException or forward a Cj_DLLException or Cj_SymbolMissingException
JLOG(4,                 std::cout << "loadOneDLLToNewFactory returned size delta of " << loaded_factory.size()-new_factory.size() << " when loading " << *it << std::endl; )
                        // above fn already checks for name conflicts in new_entries
                }
                catch(Cj_NameCollisionException & e) {
//                      std::cout << "Unexpected error \"" << e.what() << "\" occured when loading DLL from file " << *it << std::endl;
                        assert(!continueOnFail);                // this should be fatal to the program
                        throw;  // let it propagate up - we've been asked to complain on failure - well, a dupe name is a failure.
                        }
                catch(Cj_SymbolMissingException & e) {
                        JLOG(4,                 std::cout << "Missing symbols when loading " << *it << ": \"" << e.what() << "\"" << std::endl; )       // this will happen when we're looking for a different kind of factory than is in the file
                        continue;
                }
                // new entries already added in loaded_factory - copy to new_factory
                new_factory.swap(loaded_factory);
        }
JLOG(4, std::cout << "CjVisitorFactory::loadAll: factory size delta is " << new_factory.size()-m_factory.size() << std::endl; )
        swap(m_factory, new_factory);
}


void loadOne(const char * fname, const char * create_name, const char * destroy_name, const char * getnames_name, const char * getproperty_name, bool continueOnDupe = false, const bool overwriteExisting = false ) {  // could throw string describing error
        factory_t loaded_factory (loadOneDLLToFactoryCopy( fname, create_name, destroy_name, getnames_name, getproperty_name, continueOnDupe, overwriteExisting, &m_factory ) ); // throws string on missing file or missing symbols
        // above fn already checks for name conflicts with m_factory
        // some or all of the factory entries have now been loaded into loaded_factory
        std::swap(m_factory, loaded_factory);
}


static factory_t loadOneDLLToFactoryCopy( const char * fname, const char * create_name, const char * destroy_name, const char * getnames_name, const char * getproperty_name, const bool continueOnDupe, const bool overwriteExisting, const factory_t * old_factory = 0 ) {
        factory_t new_factory;
        if(old_factory) new_factory = *old_factory;
        boost::shared_ptr<FacEntryType> fe (new FacEntryType ( fname, create_name, destroy_name, getnames_name, getproperty_name ));    // could throw Cj_DLLException or Cj_SymbolMissingException
        std::vector< std::string > obj_names ((fe->n())());
        // for the newly loaded DLL check every name against ones in new_factory
        for(std::vector< std::string >::const_iterator i = obj_names.begin(); i != obj_names.end(); ++i ) {
// ///          if(log) std::cout << "CjVisitorFactory::loadOneDLLToNewFactory(...): Testing " << *i << " from " << fname << std::endl;
                typename factory_t::iterator old (new_factory.find(*i));
                if(new_factory.end() != old) { // found dupe name..
                        if(!continueOnDupe) throw Cj_NameCollisionException( std::string("CjVisitorFactory::loadOneDLLToNewFactory( const char * fname, const factory_t * old_factory, const bool continueOnDupe, const bool overwriteExisting ): When attempting to load ") + fname + " found duplicate " + *i );      // DLL automagically closed when share_ptr kills entry
                        if(overwriteExisting) new_factory.erase(old);
                        else continue;  // skip to next name
                }
                std::pair < typename factory_t::iterator , bool > ins (new_factory.insert( make_pair ( *i, fe ) ));
                assert(ins.second);
        }
        return new_factory;
}
#endif // BUILD_STATIC_MITIE


Visitor_shared_ptr createInstance_sharedptr( const std::string & name, const std::string & args, const VisitorArgumentType & va ) const {
        JLOG(5, std::cout << "CjVisitorFactory::createInstance_sharedptr(\"" << name << "\", \"" << args << "\") called." << std::endl; )
        typename factory_t::const_iterator it = m_factory.find(name);
        if( m_factory.end() == it ) throw Cj_NotFoundInFactoryException("CjVisitorFactory::createInstance_sharedptr(const std::string & name, const std::string & args, const VisitorArgumentType * ): " + name + " not found in factory");
        return Visitor_shared_ptr( it->second->c()( name, args, va ), it->second->d() );        // created with a custom deleter - the one from the DLL
}


std::string getProperty(const std::string & name, const std::string & prop_name) const {
        typename factory_t::const_iterator it = m_factory.find(name);
        if( m_factory.end() == it ) throw Cj_NotFoundInFactoryException("CjVisitorFactory::getUsage(const std::string & name, const std::string & args ): " + name + " not found in factory");
        return it->second->p()( name, prop_name );
}

std::vector < std::string > getRegisteredNames() const {
        std::vector < std::string > v;
        for(typename factory_t::const_iterator it = m_factory.begin(); it != m_factory.end(); ++it) v.push_back(it->first);
        return v;
}

};

} // namespace jmitie

#endif // _CJVISITORFACTORY_H_