src.libs/mitie_lib_template.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/>.
 */

/*
 * This header file is kind of a hack to emulate template-like behaviour for extern C code..
 * Before this code is included the following #defines must be made:
 * CREATED_OBJ_LIST must be the name of a typedef of type boost::mpl::list and its contents must be the classes
 *  which are to be added to the factory
 * e.g. typedef boost::mpl::list< CjNP_grow, CjNP_addLink, CjNP_remLink > objtypes
 * #define CREATED_OBJ_LIST objtypes
 * CREATED_OBJ_TYPE must be #define as the type produced by this factory, e.g. CjNetworkProcess
 * FUNNAME_SUFFIX must be #defined as the suffix of the function names - create_, destroy_ getNames_ and getProperty_
 * i.e. if FUNNAME_SUFFIX is proc then the exported function names are create_proc, destroy_proc, getNames_proc, and getProperty_proc
 * 
 * see mitie_core_np.cc for sample usage
 */

// Everything below is deliberately in the default namespace because it is intended to be embedded in other code

#define STRINGIFY(x) #x
#define TOSTRING(x) STRINGIFY(x)

#include <iostream>
#include <vector>
#include <utility>
#include <string>
#include <stdexcept>
#include <memory>
#include <boost/mpl/for_each.hpp>
#include <boost/mpl/transform.hpp>
#include <boost/type_traits/add_pointer.hpp>    // for add_pointer in mpl::transform
// #include <boost/bind/placeholders.hpp>       // for _1 for add_pointer
#include <boost/preprocessor/cat.hpp>
#include "JLOG.hh"

#ifdef _MSC_VER
// disable complaints about returning C++ UDTs from C linkage functions in mitie_lib_template.hh
#pragma warning(disable:4190)
#endif

#ifndef FUNNAME_SUFFIX
#error "FUNNAME_SUFFIX must be specified."
#endif

#undef CREATE_OBJ_FUNNAME
#undef DESTROY_OBJ_FUNNAME
#undef GETNAMES_FUNNAME
#undef GETPROPERTY_FUNNAME

#define CREATE_OBJ_PREFIX create_
#define DESTROY_OBJ_PREFIX destroy_
#define GETNAMES_PREFIX getNames_
#define GETPROPERTY_PREFIX getProperty_

#define CREATE_OBJ_FUNNAME BOOST_PP_CAT( CREATE_OBJ_PREFIX, FUNNAME_SUFFIX )
#define DESTROY_OBJ_FUNNAME BOOST_PP_CAT( DESTROY_OBJ_PREFIX, FUNNAME_SUFFIX )
#define GETNAMES_FUNNAME BOOST_PP_CAT( GETNAMES_PREFIX, FUNNAME_SUFFIX )
#define GETPROPERTY_FUNNAME BOOST_PP_CAT( GETPROPERTY_PREFIX, FUNNAME_SUFFIX )

#ifndef __MITIE_LIB_TEMPLATE_H_
#define __MITIE_LIB_TEMPLATE_H_ 1

struct append_name_to_list { // could throw anything that default constructor of listed types could throw
        std::vector< std::string > & m_v;
        append_name_to_list(std::vector< std::string > & v):m_v(v) {};
    template<typename U> void operator()(U *) {
                std::string n(U::getName_static());
JLOG(5,         std::cout << "Adding " << n << " to list." << std::endl; )
                m_v.push_back( n );
    }
};


struct lookup_property {        // could throw anything that default constructor of listed types could throw
        const std::string & m_name;                     // the name of the class that we want the property for
        const std::string & m_prop_name;        // the name of the property we are looking for
        std::string & m_prop;           // stores the value of the looked up property name

        lookup_property( const std::string & class_name, const std::string & prop_name, std::string & prop ):m_name(class_name), m_prop_name(prop_name), m_prop(prop) {
JLOG(4,         std::cout << "Will be looking for: " << prop_name << " of class " << m_name << std::endl; )
                };
    template<typename U> void operator()(U *) {
JLOG(6, std::cout << "_" << m_name << "_ compared against _" << U::getName_static() << "_" << std::endl; )
                if((m_prop.empty())&&(m_name.compare(U::getName_static())==0)) {
JLOG(4,                 std::cout << "Found it, getting property.." << std::endl; )
                        m_prop = U::getProperty_static(m_prop_name);
                }
    }
};

#endif

// the code below is expected to be "instatiated" under different names for each new FUNNAME_SUFFIX and therefore is outside the include guard

struct LOOKUP_CREATE_FUNNAME {  // could throw anything that constructor of found type could throw
        const std::string & m_name;
        std::auto_ptr < CREATED_OBJ_TYPE > & m_obj_ptr;
        const std::string & m_args;
        const CREATED_OBJ_TYPE::ctor_va_t & m_var_arg;
        LOOKUP_CREATE_FUNNAME( const std::string & name, std::auto_ptr < CREATED_OBJ_TYPE > & obj_ptr, const std::string & args, const CREATED_OBJ_TYPE::ctor_va_t & var_arg ):m_name(name),m_obj_ptr(obj_ptr),m_args(args),m_var_arg(var_arg) {};
    template<typename U> void operator()(U *) {
JLOG(5,         std::cout << "_" << m_name << "_ compared against _" << U::getName_static() << "_" << std::endl; )
                if( (m_obj_ptr.get()==0) && (m_name.compare(U::getName_static())==0) ) {
                        m_obj_ptr = std::auto_ptr < CREATED_OBJ_TYPE >(new U(m_args, m_var_arg));       // U ctor could throw
//                      std::cout << "Created " << m_name << std::endl;
                }
    }
};

extern "C" {

CREATED_OBJ_TYPE * CREATE_OBJ_FUNNAME (const std::string & name, const std::string & args, const CREATED_OBJ_TYPE::ctor_va_t & var_arg) {
        std::auto_ptr < CREATED_OBJ_TYPE > created(0);
        LOOKUP_CREATE_FUNNAME real_factory(name, created, args, var_arg);
        boost::mpl::for_each< boost::mpl::transform< CREATED_OBJ_LIST, boost::add_pointer<boost::mpl::_1> >::type >(real_factory);
        if(created.get()==0) throw std::runtime_error("Unknown type (" + name + ") requested of " + TOSTRING(CREATE_OBJ_FUNNAME) );
        return created.release();
        }

void DESTROY_OBJ_FUNNAME (CREATED_OBJ_TYPE * p) {
        JLOG(4, std::cout << "void " << TOSTRING(DESTROY_OBJ_FUNNAME) << "(" << TOSTRING(CREATED_OBJ_TYPE) << " * p (" << p << ")) called." << std::endl; )
        delete p;
        }

std::vector< std::string  > GETNAMES_FUNNAME () {
        std::vector< std::string  > output;
        append_name_to_list output_inserter(output);
        boost::mpl::for_each< boost::mpl::transform<CREATED_OBJ_LIST,boost::add_pointer<boost::mpl::_1> >::type >(output_inserter);
        return output;
}


std::string GETPROPERTY_FUNNAME (const std::string & name, const std::string & prop_name ) {
        std::string prop;
        lookup_property real_factory(name, prop_name, prop );
        boost::mpl::for_each< boost::mpl::transform<CREATED_OBJ_LIST,boost::add_pointer<boost::mpl::_1> >::type >(real_factory);
        return prop;
}

}